Add a check for the resolvability of dependencies version requirements

Config.toml.example

@@ -0,0 +1,11 @@
+# Repository list to be used for the different checks
+# The order in which the repositories are tested will be the same as the order here
+
+[repositories.stable]
+url = "https://stable.raven-os.org"
+
+[repositories.beta]
+url = "https://beta.raven-os.org"
+
+[repositories.unstable]
+url = "https://unstable.raven-os.org"

README.md

@@ -1,3 +1,25 @@
 # NPF Checker
 
 A checker that ensure the validity and conformance of a NPF
+
+
+## Config.toml
+This file is used to provide additional configuration. It is by default `Config.toml`, but can be changed through `--config`, however only [TOML](https://github.com/toml-lang/toml) is supported.
+
+Currently, it is only used to provide the list of repositories through which `npf-checker` will go when running checks which require repositories.
+
+The order in which the repositories are listed in this config file will also be the order in which they will be used in the checks.
+
+An entry needs only a `url` key and its associated value.
+
+
+##### Example:
+
+```toml
+[repositories.thenameofmyrepository]
+url = "https://my-repository.com"
+
+```
+
+If we were to take the repository from the package `beta::kernel/linux`, the name of the repository would be `beta`, and the url would be https://raven-os.org
+

core/args.py

@@ -37,6 +37,15 @@ def parse_args():
         action='store_true',
         help="Try to use more visual tools (only makes sense with --action=edit, which is the default)"
     )
+    _parser.add_argument(
+        '--config',
+        default=os.path.join(
+            os.getcwd(),
+            os.path.dirname(sys.argv[0]),
+            'Config.toml',
+        ),
+        help="The location of the configuration file. Default: Config.toml",
+    )
     _args = _parser.parse_args()
 
 

core/check.py

@@ -1,9 +1,11 @@
 import core.checks.executable as exe
 import core.checks.syntax_check as stx
+import core.checks.version_reqs_resolvability as verreqsolv
 import core.checks.version_validity as version
 
 
 def check_package(pkg):
     exe.ExecCheck().run()
     stx.DescriptionCheck(pkg).run()
+    verreqsolv.VersionReqsResolvabilityCheck(pkg).run()
     version.VersionValidityCheck(pkg).run()

core/checks/version_reqs_resolvability.py

@@ -0,0 +1,79 @@
+import json
+import requests
+import semver
+import core.log as log
+import core.checks.base as base
+import core.config
+import core.args
+
+
+class VersionReqsResolvabilityCheck(base.CheckWithManifest):
+    def __init__(self, pkg):
+        super().__init__(pkg, list(pkg.manifest['dependencies'].items()))
+        self.highest_version = ""
+        self.repo_error = False
+        self.pkg_error = False
+        self.version_error = False
+        self.repos = core.config.get()['repositories']
+
+    def run(self):
+        log.s("Checking the version requirement solvability of dependencies")
+        super().run()
+
+    def validate(self, item):
+        self.repo_error = False
+        self.pkg_error = False
+        self.version_error = False
+        full_name, version_req = item
+        log.i(f"Checking {full_name}#{version_req}")
+        try:
+            repo_url, category, name = self.split_pkg_name(full_name)
+        except KeyError:
+            self.repo_error = True
+            return False
+        resp = requests.get(f'{repo_url}/api/p/{category}/{name}')
+        if resp.ok:
+            content = json.loads(resp.content)
+            match = semver.max_satisfying(
+                    content['versions'],
+                    version_req,
+            )
+            if match is None:
+                self.version_error = True
+                self.highest_version = semver.max_satisfying(
+                        content['versions'],
+                        '*',
+                )
+                return False
+            return True
+        else:
+            self.pkg_error = True
+            return False
+
+    def split_pkg_name(self, pkg_name):
+        repository, rest = pkg_name.split('::')
+        category, name = rest.split('/')
+        repo_url = self.repos[repository]['url']
+        return repo_url, category, name
+
+    def show(self, item):
+        full_name, version_req = item
+        if self.pkg_error:
+            log.e(f"Package wasn't found")
+        elif self.version_error:
+            log.e(f"No version was found for requirement {version_req}")
+        elif self.repo_error:
+            log.e(f"The repository for {item} isn't defined in {core.args.get_args().config}")
+
+    def diff(self, item):
+        if self.pkg_error or self.repo_error:
+            log.i(f"Dependency would be removed")
+        elif self.version_error:
+            log.i(f"The version would be changed to the highest available: '{self.highest_version}'")
+
+    def fix(self, item):
+        if self.pkg_error or self.repo_error:
+            del self.pkg.manifest['dependencies'][item[0]]
+        elif self.version_error:
+            self.pkg.manifest['dependencies'][item[0]] = self.highest_version
+        self.write_pkg_manifest()

core/config.py

@@ -0,0 +1,27 @@
+import sys
+import toml
+import core.args
+import core.log as log
+
+global _config
+
+
+def load():
+    global _config
+    _config = toml.load(core.args.get_args().config)
+    _check_file()
+
+
+def _check_file():
+    error = False
+    for repo_name in _config['repositories']:
+        repo = _config['repositories'][repo_name]
+        if 'url' not in repo:
+            log.e(f"A 'url' field is missing in Config.toml for repository '{repo_name}'")
+            error = True
+    if error:
+        sys.exit(1)
+
+
+def get():
+    return _config

npf-checker.py

@@ -1,17 +1,21 @@
 #!/usr/bin/env python3
 
 import core.args
+import core.config
 import core.package
 import core.log as log
 import core.checks.base as base
 
 
 def main():
     core.args.parse_args()
+    core.config.load()
+
     args = core.args.get_args()
     base.Check.global_state = base.Type.from_string(core.args.get_args().action)
     f = args.npf
     pkg = core.package.Package(f)
+
     log.s(f"Unwrapping {f}")
     pkg.unwrap()
     log.s(f"Checking {f}")