kamp/fdroidserver
1
0
Fork 0
mirror of https://gitlab.com/fdroid/fdroidserver.git synced 2024-11-15 03:20:10 +01:00
Code Activity
099c98bc60
fdroidserver/tests/metadata/dump/org.adaway.yaml

1066 lines
20 KiB
YAML
Raw Normal View History

convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
AntiFeatures: []
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
ArchivePolicy: null
AuthorEmail: null
AuthorName: null
support "Author Web Site" as metadata field Fastlane Supply, Triple-T Gradle Play Publisher, and many app stores include the possibility to specify a website for the author, as distinct from the website for the app. closes #204
2017-04-14 14:23:07 +02:00
AuthorWebSite: null
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
AutoName: AdAway
AutoUpdateMode: Version v%v
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Binaries: null
Bitcoin: null
Categories:
- System
- Security
Changelog: ''
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
CurrentVersion: '3.0'
CurrentVersionCode: '52'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Description: 'An ad blocker that uses the hosts file. The hosts file
contains a list of mappings between hostnames and IP addresses. When
an app requests an ad, that request is directed to 127.0.0.1 which does
nothing. There are options to run a web server
to respond to blocked hostnames and to direct requests to the IP
address of your choosing. You can download hosts files from the
app but it is possible to use your own and to add certain sites
to the white- and black-lists.
[https://github.com/dschuermann/ad-away/raw/HEAD/CHANGELOG Changelog]
Requires root: Yes. The hosts files is located in /system which is normally
read-only.'
Disabled: null
Donate: http://sufficientlysecure.org/index.php/adaway
FlattrID: '369138'
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
IssueTracker: https://github.com/dschuermann/ad-away/issues
Add Liberapay support
2017-12-12 10:53:34 +01:00
LiberapayID: null
make tests pass new lint rules
2017-05-15 16:58:10 +02:00
License: GPL-3.0
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Litecoin: null
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
MaintainerNotes: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Name: null
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
NoSourceSince: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Provides: org.sufficientlysecure.adaway
Repo: https://github.com/dschuermann/ad-away.git
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
RepoType: git
RequiresRoot: true
SourceCode: https://github.com/dschuermann/ad-away
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
Summary: Block advertisements
convert App to subclass of dict to support parsing/dumping libs Python is heavily based on its core data types, and dict is one of the more important ones. Even classes are basically a wrapper around a dict. This converts metadata.App to be a subclass of dict so it can behave like a dict when being dumped and loaded. This makes its drastically easier to use different data formats for build metadata and for sending data to the client. This approach will ultimately mean we no longer have to maintain custom parsing and dumping code. This also means then that the YAML/JSON field names will not have spaces in them, and they will match exactly what it used as the dict keys once the data is parsed, as well as matching exactly the instance attribute names: * CurrentVersion: 1.2.6 * app['CurrentVersion'] == '1.2.6' * app.CurrentVersion == '1.2.6' Inspired by: https://goodcode.io/articles/python-dict-object/
2016-11-23 17:25:59 +01:00
UpdateCheckData: null
UpdateCheckIgnore: null
UpdateCheckMode: Tags
UpdateCheckName: null
VercodeOperation: null
WebSite: http://sufficientlysecure.org/index.php/adaway
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
added: null
builds:
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: ea5378a94ee0dc1d99d2cec95fae7e6d81afb2b9
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '13'
versionName: '1.12'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 4128e59da2eac5c2904c7c7568d298ca51e79540
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch:
- defprop.patch
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '16'
versionName: '1.15'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 0b9985398b9eef7baf6aadd0dbb12002bc199d2e
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch:
- defprop.patch
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '19'
versionName: '1.18'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: ab27f4dab5f3ea5e228cfb4a6b0e1fbf53695f22
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch:
- defprop.patch
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '20'
versionName: '1.19'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 695e3801e4081026c8f7213a2345fc451d5eb89c
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch:
- defprop.patch
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '21'
versionName: '1.20'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 65138c11cc8b6affd28b68e125fbc1dff0886a4e
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch:
- defprop.patch
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '22'
versionName: '1.21'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: unknown - see disabled
disable: no source in repo
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: null
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '24'
versionName: '1.23'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: f811e53e1e1d2ee047b18715fd7d2072b90ae76b
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '25'
versionName: '1.24'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: ff97932761cdee68638dc2550751a64b2cbe18e7
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '26'
versionName: '1.25'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 33d4d80998f30bafc88c04c80cbae00b03916f99
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '27'
versionName: '1.26'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 743d25a7e287505461f33f4b8e57e4cf988fffea
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '28'
versionName: '1.27'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: eaa07f4
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '30'
versionName: '1.29'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 71ced3f
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
&& rm libs/android-support-v4.jar
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '33'
versionName: '1.32'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 9d63c18
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '34'
versionName: '1.33'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: f2568b1
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
&& android update project -p ../org_donations
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '35'
versionName: '1.34'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 7442d5d
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
&& android update project -p ../org_donations
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '36'
versionName: '1.35'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 83fc713
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
&& android update project -p ../org_donations
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '37'
versionName: '1.36'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni: []
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: 70da32b567122b701cdcb1609b780eb85732028f
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: android update project -p ../com_actionbarsherlock && rm -rf libs/armeabi/*
&& android update project -p ../org_donations
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: org_adaway/
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '38'
versionName: '1.37'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate:
- .
- android-libs/Donations
- android-libs/ActionBarSherlock
- android-libs/HtmlSpanner/htmlspanner
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.1
disable: false
encoding: null
extlibs:
- htmlcleaner/htmlcleaner-2.2.jar
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: rm android-libs/Donations/custom_rules.xml && git clone https://github.com/dschuermann/HtmlSpanner
android-libs/HtmlSpanner
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: rm -rf ../update_zip libs/root-commands-1.2.jar libs/htmlspanner-0.2-fork.jar
&& cp -f libs/htmlcleaner-2.2.jar android-libs/HtmlSpanner/htmlspanner/libs/ &&
echo "android.library.reference.3=$$RootCommands$$" >> project.properties && echo
"android.library.reference.4=android-libs/HtmlSpanner/htmlspanner" >> project.properties
&& find . -type f -print0 | xargs -0 sed -i 's/org.rootcommands/org.sufficientlysecure.rootcommands/g'
&& cp android-libs/Donations/ant-templates/other/DonationsConfig.java android-libs/Donations/src/org/donations/
rm: []
scandelete: []
scanignore: []
srclibs:
- RootCommands@c940b0e503
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '40'
versionName: '2.1'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate:
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
- .
- android-libs/Donations
- android-libs/ActionBarSherlock
- android-libs/HtmlSpanner/htmlspanner
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.3
disable: false
encoding: null
extlibs:
- htmlcleaner/htmlcleaner-2.2.jar
forcevercode: false
forceversion: false
gradle: []
gradleprops: []
init: rm android-libs/Donations/custom_rules.xml && git clone https://github.com/dschuermann/HtmlSpanner
android-libs/HtmlSpanner
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble: []
prebuild: rm -rf ../update_zip libs/root-commands-1.2.jar libs/htmlspanner-0.2-fork.jar
&& cp -f libs/htmlcleaner-2.2.jar android-libs/HtmlSpanner/htmlspanner/libs/ &&
echo "android.library.reference.3=$$RootCommands$$" >> project.properties && echo
"android.library.reference.4=android-libs/HtmlSpanner/htmlspanner" >> project.properties
&& find . -type f -print0 | xargs -0 sed -i 's/org.rootcommands/org.sufficientlysecure.rootcommands/g'
&& cp android-libs/Donations/ant-templates/other/DonationsConfig.java android-libs/Donations/src/org/donations/
rm: []
scandelete: []
scanignore: []
srclibs:
- RootCommands@c940b0e503
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '42'
versionName: '2.3'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.6
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '45'
versionName: '2.6'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.7
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '46'
versionName: '2.7'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.8
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '47'
versionName: '2.8'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.8.1
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '48'
versionName: 2.8.1
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.9
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '49'
versionName: '2.9'
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.9.1
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '50'
versionName: 2.9.1
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v2.9.2
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '51'
versionName: 2.9.2
convert metadata.Build to a subclass of dict Like with the App class in the commit before, this makes it a lot easier to work with this data when converting between the internal formats and external formats like YAML, JSON, MsgPack, protobuf, etc. The one unfortunate thing here is Build.update. It becomes dict.update(), which is a method not an attribute. build.get('update') or build['update'] could be used, but that would be oddly inconsistent. So instead the field is renamed to 'androidupdate', except for in the .txt v0 metadata files. This better describes what field does anyway, since it runs `android update`. Build.update is only referenced in two places right next to each other for the ant builds, so this change still seems worthwhile.
2016-11-29 13:26:32 +01:00
- androidupdate: []
antcommands: []
support manually adding per-build antiFeatures in metadata For cases like the OpenVPN vuln that was recently announced, it is useful for fdroiddata maintainers to be able to mark builds that have known vulnerabilities.
2017-06-27 23:55:38 +02:00
antifeatures: []
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
build: ''
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
buildjni:
- 'yes'
Test metadata files updated.
2017-06-21 08:26:52 +02:00
buildozer: false
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
commit: v3.0
disable: false
encoding: null
extlibs: []
forcevercode: false
forceversion: false
normalize Build TYPE_LIST data based on .txt In the future, we should have better internal datatypes for this stuff, i.e. instead of gradle: ['yes'] for True, actually use a boolean. For now, make the YAML and JSON metadata produce the same internal data as .txt.
2017-02-23 18:54:33 +01:00
gradle:
- 'yes'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
gradleprops: []
init: ''
maven: false
ndk: null
novcheck: false
oldsdkloc: false
output: null
patch: []
preassemble:
- renameExecutables
prebuild: ''
rm: []
scandelete: []
scanignore: []
srclibs: []
subdir: AdAway
submodules: false
support configing buildserver VM per-build with sudo= This adds the 'sudo' build field, which is just a script that is run as root. For more info, see the issue that this closes: refs #318 closes #317
2017-06-28 23:01:45 +02:00
sudo: ''
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
target: null
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
versionCode: '52'
versionName: '3.0'
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
comments:
build:40:
- '#RootCommands srclib needs changing on fdroidserver'
build:42:
- '#RootCommands srclib needs changing on fdroidserver'
id: org.adaway
rename lastupdated to lastUpdated to match fdroid client This lets index-v1 be parsed directly into class instances because the field/instance var names match exactly. The original index v0 element must retain the 'lastupdated' name for backwards compatibility.
2016-11-28 21:17:22 +01:00
lastUpdated: null
convert metadata test dumps to YAML for easy comparison When making code changes related to the metadata parsing, it is useful to see how the internal format has changed by seeing the differences in the dump files. Those files are currently in the binary .pickle format. This just straight converts them to YAML, which is a text format, so that normal diff tools work to see changes. The dump files are named .yaml instead of .yml since .yml is used for hand- edited YAML files for fdroiddata/metadata, while these dump files here are a human readable form of a Python pickle.
2016-11-23 15:14:44 +01:00
metadatapath: metadata/org.adaway.json
Copy Permalink