Merge branch 'fix_licence_setup' into 'master'

Update Licence in setup.py to AGPLv3

See merge request !79

Update Licence in setup.py to AGPLv3

import: fix import -u from fdroiddata

Have -u take precedence over .git checking to fix import -u being run from
fdroiddata.

Deduplicate statsdir

Replace some hard-coded paths with os.path.join

import: do set root_dir if running from a repo

Merge branch 'dont-use-sudo-brew' into 'master'

Don't recommend using sudo with Homebrew

Homebrew [doesn't recommend using `sudo`][1], so update the README to reflect that.

 [1]: https://github.com/Homebrew/homebrew/blob/master/share/doc/homebrew/FAQ.md#why-does-homebrew-say-sudo-is-bad-

See merge request !78

scanner: avoid checking if usual files are binary

Rewrite scanner logic

Initially, the scanner used libmagic which used magic numbers in the file's
content to detect what kind of file it appears to be. Since that library isn't
available on all systems, we added support for two other libraries, mimetypes
amongst them.

The issue with mimetypes is that it only uses the file's extension, not its
actual content. So this ends in variable behaviour depending on what system
you're using fdroidserver on. For example, an executable binary without
extension would be ignored if mimetypes was being used.

We now drop all libraries - mimetypes too as it depends on the system's
mime.types file - and instead check extensions ourselves. On top of that, do
a simple binary content check to find binary executables that don't have an
extension.

The new in-house code without any dependencies doesn't add any new checks, so
no builds should break. The current checks still work:

 % fdroid scanner app.openconnect:1029
[...]
Found executable binary at assets/raw/armeabi/curl
Found executable binary at assets/raw/mips/curl
Found executable binary at assets/raw/x86/curl
Found JAR file at lib/XposedBridgeApi-54.jar
Found JAR file at libs/acra-4.5.0.jar
Found JAR file at libs/openconnect-wrapper.jar
Found JAR file at libs/stoken-wrapper.jar
Found shared library at libs/armeabi/libopenconnect.so
Found shared library at libs/armeabi/libstoken.so
Found shared library at libs/mips/libopenconnect.so
Found shared library at libs/mips/libstoken.so
Found shared library at libs/x86/libopenconnect.so
Found shared library at libs/x86/libstoken.so

scanner: support apps using srclib repo type

Don't recommend using sudo with Homebrew

all: deduplicate -v/-q setup

lint: small cleanup

lint: catch more duplicate links

checkupdates: Avoid variable/string names as CV

Allow slashes in tags

The wikipedia app uses them, for example.

metadata: don't break words nor on hyphens

lint: add dumb support for multiline links

lint: move regex closer to usage

metadata: allow links spanning multiple lines

This allows for nicer text wrapping.

lint: remove now obsolete description checks

Wrap descriptions to 80 chars

metadata: rewrite multiline field writing

Now description text wrapping can be added.

Ensure that builds are always sorted when writing

This might not be true if builds are appended by e.g. checkupdates --auto.
This ensures that we sort them again before writing.

lint: overhaul, cleaner and saner output

lint: move lastbuild into separate function

lint: remove "no recommended build" check

In some cases we do want to not recommend any version. The client should more
or less gracefully handle this.

Merge branch 'import-tweaks-and-tests' into 'master'

Import tweaks and tests

This makes the code for `fdroid import` a bit more flexible and adds tests for the first time.  It also comments out options in `examples/config.py` that just mirror the defaults to make it clear that they are defaults, and help illustrate other options (this is standard procedure in default config files).

More details in the commit messages.

See merge request !76

lint: cleanup, remove stale sites

comment out things that are default values in examples/config.py

Since these are already defaults, there is no need to set them as defaults
in the default config.

add a basic test of `fdroid import`

import: append .git to gitlab URLs, git sometimes freaks out otherwise

From my experience, gitlab URLs need to end in .git for git to always be
happy using them.

import: split out URL handling into its own function

This is preparation to add other import methods, like checking if the
command was run in a currently checked out git repo.

Merge branch 'replace_optparse_with_argparse' into 'master'

replace deprecated optparse with argparse

squashed and rebased merge request fdroid/fdroidserver!74

following guidelines from:
https://docs.python.org/2/library/argparse.html#upgrading-optparse-code
except, still using option = parse.parse_args() instead of args = ...

- using the following script in folder fdroidserver:
```
for i in *.py; do
sed -i -e 's/optparse/argparse/' \
-e 's/OptionParser/ArgumentParser/' \
-e 's/OptionError/ArgumentError/' \
-e 's/add_option/add_argument/' \
-e 's/(options, args) = parser/options = parser/' \
-e 's/options, args = parser/options = parser/' \
-e 's/Usage: %prog/%(prog)s/' $i;
done
```
- use ArgumentParser argument to replace (option, args) = parser.parse()
  call
- use parser.error(msg) instead of raise ArgumentException as suggested
  in https://docs.python.org/2/library/argparse.html#exiting-methods
- in fdroid catch ArgumentError instead of OptionError

See merge request !75

rewritemeta: move debug logs to logging.debug

checkupdates: log vercode operation activity

checkupdates: don't auto update to older versions

If for whatever reason the update check results in an older version that we
didn't package, don't "update" to that version if we already packaged newer
versions.

Make builds work after 04e6f2eb and 120be433

manual: Don't reuse scanignore doc in scandelete

manual: be explicit about what scandelete does

Merge branch 'master' of https://gitlab.com/fdroid/fdroidserver

lint: Warn about links left off from old sites

checkupdates improvements for gradle projects

* Let the package name override the one found in AndroidManifest.xml
* Support the newer applicationId

Add python-yaml to buildserver

replace deprecated optparse with argparse

following guidelines from:
https://docs.python.org/2/library/argparse.html#upgrading-optparse-code
except, still using option = parse.parse_args() instead of args = ...

- using the following script in folder fdroidserver:
for i in *.py; do
sed -i -e 's/optparse/argparse/' \
-e 's/OptionParser/ArgumentParser/' \
-e 's/OptionError/ArgumentError/' \
-e 's/add_option/add_argument/' \
-e 's/(options, args) = parser/options = parser/' \
-e 's/options, args = parser/options = parser/' \
-e 's/Usage: %prog/%(prog)s/' $i;
done
- use ArgumentParser argument to replace (option, args) = parser.parse()
  call
- use parser.error(msg) instead of raise ArgumentException as suggested
  in https://docs.python.org/2/library/argparse.html#exiting-methods
- in fdroid catch ArgumentError instead of OptionError

Bump build-tools

Specify that disabled builds aren't failing builds

Fix regression introduced in 2831b3e93

An empty list of antifeatures should not be written.

End sentence spacing madness in sample config

Simplify markdown code blocks

completion: set up _fdroid_* funcs at load time

This fixes an issue where these functions would not be created until fdroid
was completed at least once.

CI: set up all SDK components in PATH

Merge branch 'ci-split-packages' into 'master'

CI: Split up package installing

Advantages:
* Easier to tell why we need each package
* apt-get install output is less scary/huge
* CI job is split in more, smaller steps easier to debug

See merge request !72

Even examples/config.py with default_config

CI: Split up package installing

Advantages:
* Easier to tell why we need each package
* apt-get install output is less scary/huge
* CI job is split in more, smaller steps easier to debug

Merge branch 'fix-pillow-gitlab-ci' into 'master'

install build dependencies for Pillow

When Pillow is installed with pip, it needs to compile the C code against a few libraries, like libjpeg.  Pillow is included in Debian/Ubuntu as 'python-imaging', so just install the build
dependencies of that, and it should all be golden.

See merge request !71

install build dependencies for Pillow

When Pillow is installed with pip, it needs to compile the C code
against a few libraries, like libjpeg.  This also adds python-git
as a dep.

CI: add missing python-virtualenv package

Merge branch 'fdroid-version' into 'master'

fdroid --version and shared tests between gitlab and jenkins

This adds a `fdroid --version` flag for people to easily see the exact version of fdroidserver in use.  It'll also report the version using `git describe` when running from git.

The other moves the extended tests out of `./jenkins-build` into a common script for both gitlab-ci and jenkins.

See merge request !70

pep8: on *.TestCase, skip "E402 module level import not at top of file"

The tests use a little hack in order to cleanly import the fdroidserver
package locally like a regular package.  pep8 doesn't see that, so this
changes the pep8 to skip E402 on *.TestCase

gitlab-ci: install all android packages at once

the `android` utility is pretty stupid, it doesn't really cache the
package index info.  So each time it is run, it tries to fetch the
indexes from the network.  This combines all android package installs
to a single command to make things run quicker.

move tests into common script for jenkins and gitlab-ci

`fdroid --version` for installed releases and running from git

This will report the version embedded in the module if it is installed, and
will report `git describe` if being run from git.  If someone installs from
git using pip, this will probably report the version in setup.py, which
will be wrong.  But that is not a documented install method, and I haven't
heard of anyone using it.  The recommended way is to run straight from git.

CI: Add missing yaml dependency

Merge branch 'support-xml-json-yaml-for-metadata' into 'master'

Support XML, JSON, and YAML for metadata

Add support for app metadata files in JSON, XML, and YAML data formats.  All of the formats use the exact same metadata tags, so there is no translation layer needed.  They all just parse the data into the same internal data format: Python dicts.  Supporting these standard formats will make it much easier for people to write recipes since they can choose a data format that they are familiar with.  It also makes it much easier to generate metadata programmatically, since there are good libraries for working with all three formats in basically every language (unlike FDroid's .txt format).

Here are the same tags in .txt, JSON, XML, and YAML:

    Source Code:https://github.com/SMSSecure/SMSSecure
    "Source Code": "https://github.com/SMSSecure/SMSSecure",
    <string name="Source Code">https://github.com/SMSSecure/SMSSecure</string>
    Source Code: https://github.com/SMSSecure/SMSSecure

Looking for comments, suggestions, flames, etc. from @CiaranG, @mvdan, and everyone else.

See merge request !57

Merge branch 'liblzma' into 'master'

Add liblzma-dev to buildserver

Ref:https://gitlab.com/fdroid/fdroiddata/merge_requests/954/

See merge request !69

set "accepted formats" for metadata in config.py

For a bit repo like f-droid.org, it makes sense to standardize on a single
format for metadata files.  This adds support for enforcing a single data
format, or a reduced set of data formats.  So f-droid.org would run like
this if it changed to YAML:

  accepted_formats = ['txt', 'yaml']

Then once everything was converted to YAML, it could look like this:

  accepted_formats = ['yaml']

rewritemeta only applies to the original .txt metadata format

make note of JSON, XML, and YAML in the manual

add 'gradleprops' to .pickle files for the metadata tests

exit with error if duplicate metadata file is found

In order to prevent confusion caused by multiple metadata files for a given
app, fdroid will exit with an error if it finds any app metadata file with
the same package ID as one that has already been parsed.

metadata: rename metafile to metadatapath when it is a path

To keep the code clear, change the code to use separate variables for the
path to the metadata file, and for the file object of the opened metadata.

metadata: use unified method for getting default app metadata dict

This puts process of setting up the defaults for the internal dict
that represents a parsed app into a single method that is reused for all
metadata formats.

support app metadata in YAML format

YAML is a format that is quite similar to the .txt format, but is a
widespread standard that has editing modes in popular editors.  It is also
easily parsable in python.

The .pickle for testing is a lightly edited version of the real metadata
for org.videolan.vlc:

 * comments were removed

set appid in get_default_app_info_list()

consolidate all post-parse metadata checks

This puts all of the needed post parsing checks on the metadata into a
single method that is used by all parsing methods (.txt, JSON, XML, YAML).
This provides the single place to normalize the internal representation of
the metadata.

It would be good to also change the internal representation to use more Python
bool/int types so that less post parsing is needed for JSON, XML, and YAML.

The SMSSecure test .pickle was changed to account for the use of lstrip()
and rstrip() on all 'script' types.

This also changes the example JSON to use ints for versionCodes

eliminate Boolean metadata type, only 'bool' is needed

No need for a specific metadata type for 'Requires Root'.  Just use 'bool',
then convert on output.  This keeps the internal representation consistent
since all boolean-ish values will be Python bools.  This in turn makes
parsing metadata in various formats easier.  This also makes setting
booleans more tolerant since all these values are valid:

 Yes yes No no True true False false

support app metadata in XML format

While the current text metadata format is good for human readability and
editability, it is difficult to produce and parse using code.  XML is a
widespread standard format for easy automatic parsing and creating, while
having decent human readability.

The .pickle for testing is a lightly edited version of the real metadata
for net.osmand.plus:

* comments were removed
* "NonFreeNet" was added as an AntiFeature

convert internal representation of AntiFeatures to list

The AntiFeatures metadata is a comma-separated list of tags, like
Categories, so it should also be stored internally as a list.  This makes
parsing XML and JSON easier.

The test cases' .pickle files look like they change a lot, but they really
don't, its only the change of default AntiFeatures value from None to []

metadata: store comments in lists since lists are used everywhere else

The only data produced by parsing metadata that was stored as a tuple was
the comments' key/values.  Everywhere else, lists are used.  This changes
the comments to also only use lists to keep the data consistent internally.
That makes it vastly easier to produce the exact same metadata dict when
parsing .txt, JSON, XML, etc.

add test case for JSON parsing, based on parsed .txt metadata

The .pickle was created by dumping the output from parsing the current .txt
metadata for org.adaway.  The JSON started from that pickle dump, but was
then hand edited to be more proper JSON, e.g. using boolean values.

in JSON metadata, convert unicode to str to match the internal format

fdroidserver currently uses plain python 2.x strings rather than unicode
strings, so the parsed JSON should produce the same format as the parsed
.txt metadata.

add test for metadata parsing based on a parse output to a pickle

This is a test to cover future modifications of the .txt metadata parsing.
The pickle file was generated by just dumping the current parsed metadata,
so this test will always succeed if the parsing is not changed.

move metadata post-parse processing to reusable function

add test files to pre-commit hook and fix pep8 errors

support app metadata in JSON format

While the current text metadata format is good for human readability and
editability, it is difficult to produce and parse using code.  JSON is a
widespread standard format for easy automatic parsing and creating, while
having decent human readability.

use common method to set up defaults in metadata dict

This is needed for the upcoming metadata formats: JSON, XML, etc.

metadata: rename parse_metadata() to parse_txt_metadata()

This makes the code clear as support for other metadata formats is added.

Move requests code out of common.py, closes #114

lint: fixed list false positives, no need for utf

lint: warn about duplicate lines

lint: catch more incorrect lists

lint: stop accepting Office as valid category

lint: accept new category Sports & Health

Add liblzma-dev to buildserver

Follow-up to 5a0129d8: also replace file mentions

lint: accept all new categories

lint: new category

lint: Wallpaper is now called Theming

lint: remove Children as valid category