handle architecture specific fields for dependencies

This change requires srcinfo at least 0.1.2 version. Unfortunatelly aur
api don't support architecture specific arrays for now, so we just leave
it as is

Closes #82

src/ahriman/application/application/application_packages.py

@@ -84,7 +84,7 @@ class ApplicationPackages(ApplicationProperties):
             without_dependencies(bool): if set, dependency check will be disabled
         """
         source_dir = Path(source)
-        package = Package.from_build(source_dir)
+        package = Package.from_build(source_dir, self.architecture)
         cache_dir = self.repository.paths.cache_for(package.base)
         shutil.copytree(source_dir, cache_dir)  # copy package to store in caches
         Sources.init(cache_dir)  # we need to run init command in directory where we do have permissions

src/ahriman/application/application/application_repository.py

@@ -111,7 +111,7 @@ class ApplicationRepository(ApplicationProperties):
 
         def unknown_local(probe: Package) -> List[str]:
             cache_dir = self.repository.paths.cache_for(probe.base)
-            local = Package.from_build(cache_dir)
+            local = Package.from_build(cache_dir, self.architecture)
             packages = set(probe.packages.keys()).difference(local.packages.keys())
             return list(packages)
 

src/ahriman/application/handlers/patch.py

@@ -58,7 +58,7 @@ class Patch(Handler):
             patch = Patch.patch_create_from_function(args.variable, args.patch)
             Patch.patch_set_create(application, args.package, patch)
         elif args.action == Action.Update and args.variable is None:
-            package_base, patch = Patch.patch_create_from_diff(args.package, args.track)
+            package_base, patch = Patch.patch_create_from_diff(args.package, architecture, args.track)
             Patch.patch_set_create(application, package_base, patch)
         elif args.action == Action.List:
             Patch.patch_set_list(application, args.package, args.variable, args.exit_code)
@@ -66,19 +66,20 @@ class Patch(Handler):
             Patch.patch_set_remove(application, args.package, args.variable)
 
     @staticmethod
-    def patch_create_from_diff(sources_dir: Path, track: List[str]) -> Tuple[str, PkgbuildPatch]:
+    def patch_create_from_diff(sources_dir: Path, architecture: str, track: List[str]) -> Tuple[str, PkgbuildPatch]:
         """
         create PKGBUILD plain diff patches from sources directory
 
         Args:
             sources_dir(Path): path to directory with the package sources
+            architecture(str): repository architecture
             track(List[str]): track files which match the glob before creating the patch
 
         Returns:
             Tuple[str, PkgbuildPatch]: package base and created PKGBUILD patch based on the diff from master HEAD
                 to current files
         """
-        package = Package.from_build(sources_dir)
+        package = Package.from_build(sources_dir, architecture)
         patch = Sources.patch_create(sources_dir, *track)
         return package.base, PkgbuildPatch(None, patch)
 

src/ahriman/core/repository/update_handler.py

@@ -98,7 +98,7 @@ class UpdateHandler(Cleaner):
             with self.in_package_context(cache_dir.name):
                 try:
                     Sources.fetch(cache_dir, remote=None)
-                    remote = Package.from_build(cache_dir)
+                    remote = Package.from_build(cache_dir, self.architecture)
 
                     local = packages.get(remote.base)
                     if local is None:

src/ahriman/models/package.py

@@ -201,12 +201,13 @@ class Package(LazyLogging):
             packages={package.name: PackageDescription.from_aur(package)})
 
     @classmethod
-    def from_build(cls: Type[Package], path: Path) -> Package:
+    def from_build(cls: Type[Package], path: Path, architecture: str) -> Package:
         """
         construct package properties from sources directory
 
         Args:
             path(Path): path to package sources directory
+            architecture(str): load package for specific architecture
 
         Returns:
             Package: package properties
@@ -220,13 +221,16 @@ class Package(LazyLogging):
             raise PackageInfoError(errors)
 
         def get_property(key: str, properties: Dict[str, Any], default: Any) -> Any:
-            return properties.get(key, srcinfo.get(key, default))
+            return properties.get(key) or srcinfo.get(key) or default
+
+        def get_list(key: str, properties: Dict[str, Any]) -> Any:
+            return get_property(key, properties, []) + get_property(f"{key}_{architecture}", properties, [])
 
         packages = {
             package: PackageDescription(
-                depends=get_property("depends", properties, []),
-                make_depends=get_property("makedepends", properties, []),
-                opt_depends=get_property("optdepends", properties, []),
+                depends=get_list("depends", properties),
+                make_depends=get_list("makedepends", properties),
+                opt_depends=get_list("optdepends", properties),
             )
             for package, properties in srcinfo["packages"].items()
         }