0.9.0

bauh/gems/arch/__init__.py

@@ -2,15 +2,23 @@ import os
 from pathlib import Path
 
 from bauh.api.constants import CACHE_PATH, CONFIG_PATH, TEMP_DIR
+from bauh.commons import resource
 
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
-BUILD_DIR = '{}/aur'.format(TEMP_DIR)
+BUILD_DIR = '{}/arch'.format(TEMP_DIR)
 ARCH_CACHE_PATH = CACHE_PATH + '/arch'
-CATEGORIES_CACHE_DIR = ARCH_CACHE_PATH + '/categories'
-CATEGORIES_FILE_PATH = CATEGORIES_CACHE_DIR + '/aur.txt'
-URL_CATEGORIES_FILE = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/aur/categories.txt'
+CATEGORIES_FILE_PATH = ARCH_CACHE_PATH + '/categories.txt'
+URL_CATEGORIES_FILE = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/arch/categories.txt'
 CONFIG_DIR = '{}/.config/bauh/arch'.format(Path.home())
 CUSTOM_MAKEPKG_FILE = '{}/makepkg.conf'.format(CONFIG_DIR)
-AUR_INDEX_FILE = '{}/aur.txt'.format(BUILD_DIR)
+AUR_INDEX_FILE = '{}/arch.txt'.format(BUILD_DIR)
 CONFIG_FILE = '{}/arch.yml'.format(CONFIG_PATH)
-SUGGESTIONS_FILE = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/aur/suggestions.txt'
+SUGGESTIONS_FILE = 'https://raw.githubusercontent.com/vinifmor/bauh-files/master/arch/aur_suggestions.txt'
+
+
+def get_icon_path() -> str:
+    return resource.get_path('img/arch.svg', ROOT_DIR)
+
+
+def get_repo_icon_path() -> str:
+    return resource.get_path('img/repo.svg', ROOT_DIR)

bauh/gems/arch/aur.py

@@ -1,17 +1,19 @@
 import logging
 import os
 import re
-from typing import Set, List
+import urllib.parse
+from typing import Set, List, Iterable, Dict
+
+import requests
 
 from bauh.api.http import HttpClient
-import urllib.parse
-
 from bauh.gems.arch import pacman, AUR_INDEX_FILE
 from bauh.gems.arch.exceptions import PackageNotFoundException
 
 URL_INFO = 'https://aur.archlinux.org/rpc/?v=5&type=info&'
 URL_SRC_INFO = 'https://aur.archlinux.org/cgit/aur.git/plain/.SRCINFO?h='
 URL_SEARCH = 'https://aur.archlinux.org/rpc/?v=5&type=search&arg='
+URL_INDEX = 'https://aur.archlinux.org/packages.gz'
 
 RE_SRCINFO_KEYS = re.compile(r'(\w+)\s+=\s+(.+)\n')
 RE_SPLIT_DEP = re.compile(r'[<>]?=')
@@ -33,7 +35,9 @@ KNOWN_LIST_FIELDS = ('validpgpkeys',
                      'source_i686',
                      'makedepends',
                      'makedepends_x86_64',
-                     'makedepends_i686')
+                     'makedepends_i686',
+                     'provides',
+                     'conflicts')
 
 
 def map_pkgbuild(pkgbuild: str) -> dict:
@@ -70,19 +74,30 @@ class AURClient:
         self.http_client = http_client
         self.logger = logger
         self.x86_64 = x86_64
+        self.srcinfo_cache = {}
 
     def search(self, words: str) -> dict:
         return self.http_client.get_json(URL_SEARCH + words)
 
-    def get_info(self, names: Set[str]) -> List[dict]:
+    def get_info(self, names: Iterable[str]) -> List[dict]:
         res = self.http_client.get_json(URL_INFO + self._map_names_as_queries(names))
         return res['results'] if res and res.get('results') else []
 
     def get_src_info(self, name: str) -> dict:
+        srcinfo = self.srcinfo_cache.get(name)
+
+        if srcinfo:
+            return srcinfo
+
         res = self.http_client.get(URL_SRC_INFO + urllib.parse.quote(name))
 
         if res and res.text:
-            return map_srcinfo(res.text)
+            srcinfo = map_srcinfo(res.text)
+
+            if srcinfo:
+                self.srcinfo_cache[name] = srcinfo
+
+            return srcinfo
 
         self.logger.warning('No .SRCINFO found for {}'.format(name))
         self.logger.info('Checking if {} is based on another package'.format(name))
@@ -96,7 +111,12 @@ class AURClient:
             info_base = info.get('PackageBase')
             if info_name and info_base and info_name != info_base:
                 self.logger.info('{p} is based on {b}. Retrieving {b} .SRCINFO'.format(p=info_name, b=info_base))
-                return self.get_src_info(info_base)
+                srcinfo = self.get_src_info(info_base)
+
+                if srcinfo:
+                    self.srcinfo_cache[name] = srcinfo
+
+                return srcinfo
 
     def extract_required_dependencies(self, srcinfo: dict) -> Set[str]:
         deps = set()
@@ -123,7 +143,7 @@ class AURClient:
         return '&'.join(['arg[{}]={}'.format(i, urllib.parse.quote(n)) for i, n in enumerate(names)])
 
     def read_local_index(self) -> dict:
-        self.logger.info('Checking if the AUR index file exists')
+        self.logger.info('Checking if the cached AUR index file exists')
         if os.path.exists(AUR_INDEX_FILE):
             self.logger.info('Reading AUR index file from {}'.format(AUR_INDEX_FILE))
             index = {}
@@ -135,3 +155,57 @@ class AURClient:
             self.logger.info("AUR index file read")
             return index
         self.logger.warning('The AUR index file was not found')
+
+    def download_names(self) -> Set[str]:
+        self.logger.info('Downloading AUR index')
+        try:
+            res = self.http_client.get(URL_INDEX)
+
+            if res and res.text:
+                return {n.strip() for n in res.text.split('\n') if n and not n.startswith('#')}
+            else:
+                self.logger.warning('No data returned from: {}'.format(URL_INDEX))
+        except requests.exceptions.ConnectionError:
+            self.logger.warning('No internet connection: could not pre-index packages')
+
+        self.logger.info("Finished")
+
+    def read_index(self) -> Iterable[str]:
+        index = self.read_local_index()
+
+        if not index:
+            self.logger.warning("Cached AUR index file not found")
+            pkgnames = self.download_names()
+
+            if pkgnames:
+                return pkgnames
+            else:
+                self.logger.warning("Could not load AUR index on the context")
+        else:
+            return index.values()
+
+    def clean_caches(self):
+        self.srcinfo_cache.clear()
+
+    def map_update_data(self, pkgname: str, latest_version: str, srcinfo: dict = None) -> dict:
+        info = self.get_src_info(pkgname) if not srcinfo else srcinfo
+
+        provided = set()
+        provided.add(pkgname)
+
+        if info:
+            provided.add('{}={}'.format(pkgname, info['pkgver']))
+            if info.get('provides'):
+                provided.update(info.get('provides'))
+
+            return {'c': info.get('conflicts'), 's': None, 'p': provided, 'r': 'arch',
+                    'v': info['pkgver'], 'd': self.extract_required_dependencies(info)}
+        else:
+            if latest_version:
+                provided.add('{}={}'.format(pkgname, latest_version))
+
+            return {'c': None, 's': None, 'p': provided, 'r': 'arch', 'v': latest_version, 'd': set()}
+
+    def fill_update_data(self, output: Dict[str, dict], pkgname: str, latest_version: str, srcinfo: dict = None):
+        data = self.map_update_data(pkgname=pkgname, latest_version=latest_version, srcinfo=srcinfo)
+        output[pkgname] = data

bauh/gems/arch/config.py

@@ -3,5 +3,12 @@ from bauh.gems.arch import CONFIG_FILE
 
 
 def read_config(update_file: bool = False) -> dict:
-    template = {'optimize': True, 'transitive_checking': True, "sync_databases": True, "simple_checking": False}
+    template = {'optimize': True,
+                "sync_databases": True,
+                "clean_cached": True,
+                'arch': True,
+                'repositories': True,
+                "refresh_mirrors_startup": False,
+                "sync_databases_startup": True,
+                'mirrors_sort_limit': 5}
     return read(CONFIG_FILE, template, update_file=update_file)

bauh/gems/arch/confirmation.py

@@ -1,23 +1,33 @@
-from typing import Set, List, Tuple
+from typing import Set, List, Tuple, Dict
 
 from bauh.api.abstract.handler import ProcessWatcher
-from bauh.api.abstract.view import MultipleSelectComponent, InputOption
+from bauh.api.abstract.view import MultipleSelectComponent, InputOption, FormComponent, SingleSelectComponent, \
+    SelectViewType
 from bauh.commons import resource
 from bauh.commons.html import bold
-from bauh.gems.arch import ROOT_DIR
+from bauh.commons.system import get_human_size_str
+from bauh.gems.arch import ROOT_DIR, get_repo_icon_path, get_icon_path, pacman
 from bauh.view.util.translation import I18n
 
 
-def _get_mirror_icon(mirror: str):
-    return resource.get_path('img/{}.svg'.format('arch' if mirror == 'aur' else 'mirror'), ROOT_DIR)
+def _get_repo_icon(repository: str):
+    return resource.get_path('img/{}.svg'.format('arch' if repository == 'arch' else 'repo'), ROOT_DIR)
 
 
-def request_optional_deps(pkgname: str, pkg_mirrors: dict, watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
+def request_optional_deps(pkgname: str, pkg_repos: dict, watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
     opts = []
 
-    for p, d in pkg_mirrors.items():
-        op = InputOption('{}{} ( {}: {} )'.format(p, ': ' + d['desc'] if d['desc'] else '', i18n['repository'], d['mirror'].upper()), p)
-        op.icon_path = _get_mirror_icon(d['mirror'])
+    repo_deps = [p for p, data in pkg_repos.items() if data['repository'] != 'arch']
+    sizes = pacman.get_update_size(repo_deps) if repo_deps else None
+
+    for p, d in pkg_repos.items():
+        size = sizes.get(p)
+        op = InputOption('{}{} ( {}: {} ) - {}: {}'.format(p, ': ' + d['desc'] if d['desc'] else '',
+                                                           i18n['repository'],
+                                                           d['repository'].upper(),
+                                                           i18n['size'].capitalize(),
+                                                           get_human_size_str(size) if size else '?'), p)
+        op.icon_path = _get_repo_icon(d['repository'])
         opts.append(op)
 
     view_opts = MultipleSelectComponent(label='',
@@ -39,15 +49,56 @@ def request_install_missing_deps(pkgname: str, deps: List[Tuple[str, str]], watc
 
     opts = []
 
-    sorted_deps = [*deps]
-    sorted_deps.sort(key=lambda e: e[0])
+    repo_deps = [d[0] for d in deps if d[1] != 'arch']
+    sizes = pacman.get_update_size(repo_deps) if repo_deps else None
 
-    for dep in sorted_deps:
-        op = InputOption('{} ( {}: {} )'.format(dep[0], i18n['repository'], dep[1].upper()), dep[0])
+    for dep in deps:
+        size = sizes.get(dep[0])
+        op = InputOption('{} ( {}: {} ) - {}: {}'.format(dep[0],
+                                                         i18n['repository'],
+                                                         dep[1].upper(),
+                                                         i18n['size'].capitalize(),
+                                                         get_human_size_str(size) if size else '?'), dep[0])
         op.read_only = True
-        op.icon_path = _get_mirror_icon(dep[1])
+        op.icon_path = _get_repo_icon(dep[1])
         opts.append(op)
 
     comp = MultipleSelectComponent(label='', options=opts, default_options=set(opts))
-
     return watcher.request_confirmation(i18n['arch.missing_deps.title'], msg, [comp], confirmation_label=i18n['continue'].capitalize(), deny_label=i18n['cancel'].capitalize())
+
+
+def request_providers(providers_map: Dict[str, Set[str]], repo_map: Dict[str, str], watcher: ProcessWatcher, i18n: I18n) -> Set[str]:
+    msg = "<p>{}.</p><p>{}.</p>".format(i18n['arch.dialog.providers.line1'],
+                                        i18n['arch.dialog.providers.line2'])
+
+    repo_icon_path = get_repo_icon_path()
+    aur_icon_path = get_icon_path()
+
+    form = FormComponent([], label='')
+
+    for dep, providers in providers_map.items():
+        opts = []
+
+        providers_list = [*providers]
+        providers_list.sort()
+
+        for p in providers_list:
+            repo = repo_map.get(p, 'arch')
+            opts.append(InputOption(label=p,
+                                    value=p,
+                                    icon_path=aur_icon_path if repo == 'arch' else repo_icon_path,
+                                    tooltip='{}: {}'.format(i18n['repository'].capitalize(), repo)))
+
+        form.components.append(SingleSelectComponent(label=bold(dep.lower()),
+                                                     options=opts,
+                                                     default_option=opts[0],
+                                                     type_=SelectViewType.COMBO,
+                                                     max_per_line=1))
+
+    if watcher.request_confirmation(title=i18n['arch.providers'].capitalize(),
+                                    body=msg,
+                                    components=[form],
+                                    confirmation_label=i18n['proceed'].capitalize(),
+                                    deny_label=i18n['cancel'].capitalize()):
+
+        return {s.get_selected() for s in form.components}

bauh/gems/arch/cpu_manager.py

@@ -0,0 +1,38 @@
+import multiprocessing
+import os
+import traceback
+
+from bauh.commons.system import new_root_subprocess
+
+
+def supports_performance_mode():
+    return os.path.exists('/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor')
+
+
+def all_in_performance() -> bool:
+    for i in range(multiprocessing.cpu_count()):
+        with open('/sys/devices/system/cpu/cpu{}/cpufreq/scaling_governor'.format(i)) as f:
+            if f.read().strip() != 'performance':
+                return False
+
+    return False
+
+
+def set_mode(mode: str, root_password: str):
+    new_gov_file = '/tmp/bauh_scaling_governor'
+    with open(new_gov_file, 'w+') as f:
+        f.write(mode)
+
+    for i in range(multiprocessing.cpu_count()):
+        try:
+            gov_file = '/sys/devices/system/cpu/cpu{}/cpufreq/scaling_governor'.format(i)
+            replace = new_root_subprocess(['cp', new_gov_file, gov_file], root_password=root_password)
+            replace.wait()
+        except:
+            traceback.print_exc()
+
+        if os.path.exists(new_gov_file):
+            try:
+                os.remove(new_gov_file)
+            except:
+                traceback.print_exc()

bauh/gems/arch/database.py

@@ -0,0 +1,52 @@
+import logging
+import os
+import time
+import traceback
+from datetime import datetime
+from logging import Logger
+from pathlib import Path
+
+from bauh.api.constants import CACHE_PATH
+from bauh.commons.system import ProcessHandler
+
+SYNC_FILE = '{}/arch/db_sync'.format(CACHE_PATH)
+
+
+def should_sync(arch_config: dict, handler: ProcessHandler, logger: logging.Logger):
+    if arch_config['arch'] or arch_config['repositories']:
+        if os.path.exists(SYNC_FILE):
+            with open(SYNC_FILE) as f:
+                sync_file = f.read()
+
+            try:
+                sync_time = datetime.fromtimestamp(int(sync_file))
+                now = datetime.now()
+
+                if now > sync_time and now.day != sync_time.day:
+                    logger.info("Package databases synchronization out of date")
+                else:
+                    msg = "Package databases already synchronized"
+                    logger.info(msg)
+                    if handler:
+                        handler.watcher.print(msg)
+                    return False
+            except:
+                logger.warning("Could not convert the database synchronization time from '{}".format(SYNC_FILE))
+                traceback.print_exc()
+        return True
+    else:
+        msg = "Package databases synchronization disabled"
+        if handler:
+            handler.watcher.print(msg)
+        logger.info(msg)
+        return False
+
+
+def register_sync(logger: Logger):
+    try:
+        Path('/'.join(SYNC_FILE.split('/')[0:-1])).mkdir(parents=True, exist_ok=True)
+        with open(SYNC_FILE, 'w+') as f:
+            f.write(str(int(time.time())))
+    except:
+        logger.error("Could not write to database sync file '{}'".format(SYNC_FILE))
+        traceback.print_exc()

bauh/gems/arch/depedencies.py

@@ -1,130 +0,0 @@
-from threading import Thread
-from typing import Set, List, Tuple
-
-from bauh.gems.arch import pacman
-from bauh.gems.arch.aur import AURClient
-
-
-class DependenciesAnalyser:
-
-    def __init__(self, aur_client: AURClient):
-        self.aur_client = aur_client
-
-    def _fill_mirror(self, name: str, output: List[Tuple[str, str]]):
-
-        mirror = pacman.read_repository_from_info(name)
-
-        if mirror:
-            output.append((name, mirror))
-            return
-
-        guess = pacman.guess_repository(name)
-
-        if guess:
-            output.append(guess)
-            return
-
-        aur_info = self.aur_client.get_src_info(name)
-
-        if aur_info:
-            output.append((name, 'aur'))
-            return
-
-        output.append((name, ''))
-
-    def get_missing_packages(self, names: Set[str], mirror: str = None, in_analysis: Set[str] = None) -> List[Tuple[str, str]]:
-        """
-        :param names:
-        :param mirror:
-        :param in_analysis: global set storing all names in analysis to avoid repeated recursion
-        :return:
-        """
-        global_in_analysis = in_analysis if in_analysis else set()
-
-        missing_names = pacman.check_missing({n for n in names if n not in in_analysis})
-
-        if missing_names:
-            missing_root = []
-            threads = []
-
-            if not mirror:
-                for name in missing_names:
-                    t = Thread(target=self._fill_mirror, args=(name, missing_root))
-                    t.start()
-                    threads.append(t)
-
-                for t in threads:
-                    t.join()
-
-                threads.clear()
-
-                # checking if there is any unknown dependency:
-                for rdep in missing_root:
-                    if not rdep[1]:
-                        return missing_root
-                    else:
-                        global_in_analysis.add(rdep[0])
-            else:
-                for missing in missing_names:
-                    missing_root.append((missing, mirror))
-                    global_in_analysis.add(missing)
-
-            missing_sub = []
-            for rdep in missing_root:
-                subdeps = self.aur_client.get_required_dependencies(rdep[0]) if rdep[1] == 'aur' else pacman.read_dependencies(rdep[0])
-                subdeps_not_analysis = {sd for sd in subdeps if sd not in global_in_analysis}
-
-                if subdeps_not_analysis:
-                    missing_subdeps = self.get_missing_packages(subdeps_not_analysis, in_analysis=global_in_analysis)
-
-                    # checking if there is any unknown:
-                    if missing_subdeps:
-                        for subdep in missing_subdeps:
-                            if not subdep[0]:
-                                return [*missing_subdeps, *missing_root]
-
-                            if subdep[0] not in missing_names:
-                                missing_sub.append(subdep)
-            return [*missing_sub, *missing_root]
-
-    def get_missing_subdeps_of(self, names: Set[str], mirror: str) -> List[Tuple[str, str]]:
-        missing = []
-        already_added = {*names}
-        in_analyses = {*names}
-
-        for name in names:
-            subdeps = self.aur_client.get_required_dependencies(name) if mirror == 'aur' else pacman.read_dependencies(name)
-
-            if subdeps:
-                missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
-
-                if missing_subdeps:
-                    for subdep in missing_subdeps:  # checking if there is any unknown:
-                        if subdep[0] not in already_added:
-                            missing.append(subdep)
-
-                        if not subdep[0]:
-                            return missing
-        return missing
-
-    def get_missing_subdeps(self, name: str, mirror: str, srcinfo: dict = None) -> List[Tuple[str, str]]:
-        missing = []
-        already_added = {name}
-        in_analyses = {name}
-
-        if mirror == 'aur':
-            subdeps = self.aur_client.get_required_dependencies(name) if not srcinfo else self.aur_client.extract_required_dependencies(srcinfo)
-        else:
-            subdeps = pacman.read_dependencies(name)
-
-        if subdeps:
-            missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
-
-            if missing_subdeps:
-                for subdep in missing_subdeps:  # checking if there is any unknown:
-                    if subdep[0] not in already_added:
-                        missing.append(subdep)
-
-                    if not subdep[0]:
-                        return missing
-        return missing

bauh/gems/arch/dependencies.py

@@ -0,0 +1,466 @@
+import re
+from distutils.version import LooseVersion
+from threading import Thread
+from typing import Set, List, Tuple, Dict, Iterable
+
+from bauh.api.abstract.handler import ProcessWatcher
+from bauh.gems.arch import pacman, message, sorting, confirmation
+from bauh.gems.arch.aur import AURClient
+from bauh.gems.arch.exceptions import PackageNotFoundException
+from bauh.view.util.translation import I18n
+
+
+class DependenciesAnalyser:
+
+    def __init__(self, aur_client: AURClient, i18n: I18n):
+        self.aur_client = aur_client
+        self.i18n = i18n
+        self.re_dep_operator = re.compile(r'([<>=]+)')
+
+    def _fill_repository(self, name: str, output: List[Tuple[str, str]]):
+
+        repository = pacman.read_repository_from_info(name)
+
+        if repository:
+            output.append((name, repository))
+            return
+
+        guess = pacman.guess_repository(name)
+
+        if guess:
+            output.append(guess)
+            return
+
+        aur_info = self.aur_client.get_src_info(name)
+
+        if aur_info:
+            output.append((name, 'arch'))
+            return
+
+        output.append((name, ''))
+
+    def get_missing_packages(self, names: Set[str], repository: str = None, in_analysis: Set[str] = None) -> List[
+        Tuple[str, str]]:
+        """
+        :param names:
+        :param repository:
+        :param in_analysis: global set storing all names in analysis to avoid repeated recursion
+        :return:
+        """
+        global_in_analysis = in_analysis if in_analysis else set()
+
+        missing_names = pacman.check_missing({n for n in names if n not in in_analysis})
+
+        if missing_names:
+            missing_root = []
+            threads = []
+
+            if not repository:
+                for name in missing_names:
+                    t = Thread(target=self._fill_repository, args=(name, missing_root))
+                    t.start()
+                    threads.append(t)
+
+                for t in threads:
+                    t.join()
+
+                threads.clear()
+
+                # checking if there is any unknown dependency:
+                for rdep in missing_root:
+                    if not rdep[1]:
+                        return missing_root
+                    else:
+                        global_in_analysis.add(rdep[0])
+            else:
+                for missing in missing_names:
+                    missing_root.append((missing, repository))
+                    global_in_analysis.add(missing)
+
+            missing_sub = []
+            for rdep in missing_root:
+                subdeps = self.aur_client.get_required_dependencies(rdep[0]) if rdep[
+                                                                                    1] == 'arch' else pacman.read_dependencies(
+                    rdep[0])
+                subdeps_not_analysis = {sd for sd in subdeps if sd not in global_in_analysis}
+
+                if subdeps_not_analysis:
+                    missing_subdeps = self.get_missing_packages(subdeps_not_analysis, in_analysis=global_in_analysis)
+
+                    # checking if there is any unknown:
+                    if missing_subdeps:
+                        for subdep in missing_subdeps:
+                            if not subdep[0]:
+                                return [*missing_subdeps, *missing_root]
+
+                            if subdep[0] not in missing_names:
+                                missing_sub.append(subdep)
+            return [*missing_sub, *missing_root]
+
+    def get_missing_subdeps_of(self, names: Set[str], repository: str) -> List[Tuple[str, str]]:
+        missing = []
+        already_added = {*names}
+        in_analyses = {*names}
+
+        for name in names:
+            subdeps = self.aur_client.get_required_dependencies(
+                name) if repository == 'arch' else pacman.read_dependencies(name)
+
+            if subdeps:
+                missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
+
+                if missing_subdeps:
+                    for subdep in missing_subdeps:  # checking if there is any unknown:
+                        if subdep[0] not in already_added:
+                            missing.append(subdep)
+
+                        if not subdep[0]:
+                            return missing
+        return missing
+
+    def get_missing_subdeps(self, name: str, repository: str, srcinfo: dict = None) -> List[Tuple[str, str]]:
+        missing = []
+        already_added = {name}
+        in_analyses = {name}
+
+        if repository == 'arch':
+            subdeps = self.aur_client.get_required_dependencies(
+                name) if not srcinfo else self.aur_client.extract_required_dependencies(srcinfo)
+        else:
+            subdeps = pacman.read_dependencies(name)
+
+        if subdeps:
+            missing_subdeps = self.get_missing_packages(subdeps, in_analysis=in_analyses)
+
+            if missing_subdeps:
+                for subdep in missing_subdeps:  # checking if there is any unknown:
+                    if subdep[0] not in already_added:
+                        missing.append(subdep)
+
+                    if not subdep[0]:
+                        return missing
+        return missing
+
+    def map_known_missing_deps(self, known_deps: Dict[str, str], watcher: ProcessWatcher, check_subdeps: bool = True) -> \
+    List[Tuple[str, str]]:
+        sorted_deps = []  # it will hold the proper order to install the missing dependencies
+
+        repo_deps, aur_deps = set(), set()
+
+        for dep, repo in known_deps.items():
+            if repo == 'arch':
+                aur_deps.add(dep)
+            else:
+                repo_deps.add(dep)
+
+        if check_subdeps:
+            for deps in ((repo_deps, 'repo'), (aur_deps, 'arch')):
+                if deps[0]:
+                    missing_subdeps = self.get_missing_subdeps_of(deps[0], deps[1])
+
+                    if missing_subdeps:
+                        for dep in missing_subdeps:
+                            if not dep[1]:
+                                message.show_dep_not_found(dep[0], self.i18n, watcher)
+                                return
+
+                        for dep in missing_subdeps:
+                            if dep not in sorted_deps:
+                                sorted_deps.append(dep)
+
+        for dep, repo in known_deps.items():
+            if repo != 'arch':
+                data = (dep, repo)
+                if data not in sorted_deps:
+                    sorted_deps.append(data)
+
+        for dep in aur_deps:
+            sorted_deps.append((dep, 'arch'))
+
+        return sorted_deps
+
+    def _fill_missing_dep(self, dep_name: str, dep_exp: str, aur_index: Iterable[str],
+                          missing_deps: Set[Tuple[str, str]],
+                          remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
+                          repo_deps: Set[str], aur_deps: Set[str], deps_data: Dict[str, dict], watcher: ProcessWatcher):
+
+        if dep_name == dep_exp:
+            providers = remote_provided_map.get(dep_name)
+        else:  # handling cases when the dep has an expression ( e.g: xpto>=0.12 )
+            providers = remote_provided_map.get(dep_exp)
+
+            if providers is None:
+                providers = remote_provided_map.get(dep_name)
+
+                if providers and len(providers) > 1:
+                    no_mapped_data = {p for p in providers if
+                                      p not in deps_data}  # checking providers with no mapped data
+
+                    if no_mapped_data:
+                        providers_data = pacman.map_updates_data(no_mapped_data)
+
+                        if not providers_data:
+                            raise Exception("Could not retrieve the info from providers: {}".format(no_mapped_data))
+
+                        deps_data.update(providers_data)  # adding missing providers data
+
+                    matched_providers = set()
+                    split_informed_dep = self.re_dep_operator.split(dep_exp)
+                    version_informed = LooseVersion(split_informed_dep[2])
+                    exp_op = split_informed_dep[1] if split_informed_dep[1] != '=' else '=='
+
+                    for p in providers:
+                        provided = deps_data[p]['p']
+
+                        for provided_exp in provided:
+                            split_dep = self.re_dep_operator.split(provided_exp)
+
+                            if len(split_dep) == 3 and split_dep[0] == dep_name:
+                                provided_version = LooseVersion(split_dep[2])
+
+                                if eval('provided_version {} version_informed'.format(exp_op)):
+                                    matched_providers.add(p)
+                                    break
+
+                    providers = matched_providers
+
+        if providers:
+            if len(providers) > 1:
+                dep_data = (dep_name, '__several__')
+            else:
+                real_name = providers.pop()
+                dep_data = (real_name, remote_repo_map.get(real_name))
+
+            repo_deps.add(dep_data[0])
+            missing_deps.add(dep_data)
+
+        elif aur_index and dep_name in aur_index:
+            aur_deps.add(dep_name)
+            missing_deps.add((dep_name, 'arch'))
+        else:
+            if watcher:
+                message.show_dep_not_found(dep_name, self.i18n, watcher)
+                raise PackageNotFoundException(dep_name)
+            else:
+                raise PackageNotFoundException(dep_name)
+
+    def __fill_aur_update_data(self, pkgname: str, output: dict):
+        output[pkgname] = self.aur_client.map_update_data(pkgname, None)
+
+    def map_missing_deps(self, pkgs_data: Dict[str, dict], provided_map: Dict[str, Set[str]],
+                         remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
+                         aur_index: Iterable[str], deps_checked: Set[str], deps_data: Dict[str, dict],
+                         sort: bool, watcher: ProcessWatcher, choose_providers: bool = True) -> List[Tuple[str, str]]:
+        sorted_deps = []  # it will hold the proper order to install the missing dependencies
+
+        missing_deps, repo_missing, aur_missing = set(), set(), set()
+
+        deps_checked.update(pkgs_data.keys())
+
+        for p, data in pkgs_data.items():
+            if data['d']:
+                for dep in data['d']:
+                    if dep in pkgs_data:
+                        continue
+                    if dep not in provided_map:
+                        dep_split = self.re_dep_operator.split(dep)
+                        dep_name = dep_split[0].strip()
+
+                        if dep_name not in deps_checked:
+                            deps_checked.add(dep_name)
+
+                            if dep_name not in provided_map:
+                                self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
+                                                       missing_deps=missing_deps,
+                                                       remote_provided_map=remote_provided_map,
+                                                       remote_repo_map=remote_repo_map,
+                                                       repo_deps=repo_missing, aur_deps=aur_missing, watcher=watcher,
+                                                       deps_data=deps_data)
+                            else:
+                                version_pattern = '{}='.format(dep_name)
+                                version_found = [p for p in provided_map if p.startswith(version_pattern)]
+
+                                if version_found:
+                                    version_found = version_found[0].split('=')[1]
+                                    version_informed = dep_split[2].strip()
+
+                                    if ':' not in version_informed:
+                                        version_found = version_found.split(':')[-1]
+
+                                    if '-' not in version_informed:
+                                        version_found = version_found.split('-')[0]
+
+                                    version_found = LooseVersion(version_found)
+                                    version_informed = LooseVersion(version_informed)
+
+                                    op = dep_split[1] if dep_split[1] != '=' else '=='
+                                    if not eval('version_found {} version_informed'.format(op)):
+                                        self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
+                                                               missing_deps=missing_deps,
+                                                               remote_provided_map=remote_provided_map,
+                                                               remote_repo_map=remote_repo_map,
+                                                               repo_deps=repo_missing, aur_deps=aur_missing,
+                                                               watcher=watcher,
+                                                               deps_data=deps_data)
+                                else:
+                                    self._fill_missing_dep(dep_name=dep_name, dep_exp=dep, aur_index=aur_index,
+                                                           missing_deps=missing_deps,
+                                                           remote_provided_map=remote_provided_map,
+                                                           remote_repo_map=remote_repo_map,
+                                                           repo_deps=repo_missing, aur_deps=aur_missing,
+                                                           watcher=watcher,
+                                                           deps_data=deps_data)
+
+        if missing_deps:
+            if repo_missing:
+                with_single_providers = []
+
+                for d in missing_deps:
+                    if d[0] in repo_missing and d[0] not in deps_data:
+                        if d[1] == '__several__':
+                            deps_data[d[0]] = {'d': None, 'p': d[0], 'r': d[1]}
+                        else:
+                            with_single_providers.append(d[0])
+
+                if with_single_providers:
+                    data = pacman.map_updates_data(with_single_providers)
+
+                    if data:
+                        deps_data.update(data)
+
+            if aur_missing:
+                aur_threads = []
+                for pkgname in aur_missing:
+                    t = Thread(target=self.__fill_aur_update_data, args=(pkgname, deps_data), daemon=True)
+                    t.start()
+                    aur_threads.append(t)
+
+                for t in aur_threads:
+                    t.join()
+
+            missing_subdeps = self.map_missing_deps(pkgs_data=deps_data, provided_map=provided_map, aur_index=aur_index,
+                                                    deps_checked=deps_checked, sort=False, deps_data=deps_data,
+                                                    watcher=watcher,
+                                                    remote_provided_map=remote_provided_map,
+                                                    remote_repo_map=remote_repo_map,
+                                                    choose_providers=False)
+
+            if missing_subdeps:
+                missing_deps.update(missing_subdeps)
+
+        if sort:
+            sorted_deps.extend(sorting.sort(deps_data.keys(), deps_data))
+        else:
+            sorted_deps.extend(((dep[0], dep[1]) for dep in missing_deps))
+
+        if sorted_deps and choose_providers:
+            return self.fill_providers_deps(missing_deps=sorted_deps, provided_map=provided_map,
+                                            remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map,
+                                            watcher=watcher, sort=sort, already_checked=deps_checked,
+                                            aur_idx=aur_index, deps_data=deps_data)
+
+        return sorted_deps
+
+    def fill_providers_deps(self, missing_deps: List[Tuple[str, str]],
+                            provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
+                            already_checked: Set[str], remote_provided_map: Dict[str, Set[str]],
+                            deps_data: Dict[str, dict], aur_idx: Iterable[str], sort: bool,
+                            watcher: ProcessWatcher) -> List[Tuple[str, str]]:
+        """
+        :param missing_deps:
+        :param provided_map:
+        :param remote_repo_map:
+        :param already_checked:
+        :param remote_provided_map:
+        :param deps_data:
+        :param aur_idx:
+        :param sort:
+        :param watcher:
+        :return: all deps sorted or None if the user declined the providers options
+        """
+
+        deps_providers = map_providers({data[0] for data in missing_deps if data[1] == '__several__'},
+                                       remote_provided_map)
+
+        if deps_providers:
+            all_providers = set()
+
+            for providers in deps_providers.values():
+                all_providers.update(providers)
+
+            providers_repos = pacman.map_repositories(all_providers)
+            selected_providers = confirmation.request_providers(deps_providers, providers_repos, watcher, self.i18n)
+
+            if not selected_providers:
+                return
+            else:
+                providers_data = pacman.map_updates_data(
+                    selected_providers)  # adding the chosen providers to re-check the missing deps
+                provided_map.update(pacman.map_provided(remote=True,
+                                                        pkgs=selected_providers))  # adding the providers as "installed" packages
+
+                providers_deps = self.map_missing_deps(pkgs_data=providers_data,
+                                                       provided_map=provided_map,
+                                                       aur_index=aur_idx,
+                                                       deps_checked=already_checked,
+                                                       deps_data=deps_data,
+                                                       sort=False,
+                                                       remote_provided_map=remote_provided_map,
+                                                       remote_repo_map=remote_repo_map,
+                                                       watcher=watcher,
+                                                       choose_providers=False)
+
+                # cleaning the already mapped providers deps:
+                to_remove = []
+
+                for idx, dep in enumerate(missing_deps):
+                    if dep[1] == '__several__':
+                        to_remove.append(idx)
+
+                for idx, to_remove in enumerate(to_remove):
+                    del missing_deps[to_remove - idx]
+
+                missing_deps.extend(((p, providers_repos.get(p, 'arch')) for p in selected_providers))
+
+                for dep in providers_deps:
+                    if dep not in missing_deps and dep[1] != '__several__':
+                        missing_deps.append(dep)
+
+                deps_data.update(providers_data)
+
+                if not self.fill_providers_deps(missing_deps=missing_deps, provided_map=provided_map,
+                                                remote_repo_map=remote_repo_map, already_checked=already_checked,
+                                                aur_idx=aur_idx, remote_provided_map=remote_provided_map,
+                                                deps_data=deps_data, sort=False, watcher=watcher):
+                    return
+
+                if sort:
+                    missing_to_sort = {d[0] for d in missing_deps if d[1] != '__several__'}
+                    return sorting.sort(missing_to_sort, deps_data, provided_map)
+
+        return missing_deps
+
+    def map_all_required_by(self, pkgnames: Iterable[str], to_ignore: Set[str]) -> Set[str]:
+        to_ignore.update(pkgnames)
+        all_requirements = {req for reqs in pacman.map_required_by(pkgnames).values() for req in reqs if req not in to_ignore}
+
+        if all_requirements:
+            sub_requirements = self.map_all_required_by(all_requirements, to_ignore)
+
+            if sub_requirements:
+                all_requirements.update(sub_requirements)
+                return all_requirements
+
+        return all_requirements
+
+
+def map_providers(pkgs: Iterable[str], remote_provided_map: Dict[str, Set[str]]) -> Dict[str, Set[str]]:
+    res = {}
+
+    for p in pkgs:
+        providers = remote_provided_map.get(p)
+
+        if providers and len(providers) > 1:
+            res[p] = providers
+
+    return res

bauh/gems/arch/disk.py

@@ -2,62 +2,73 @@ import json
 import os
 import re
 from pathlib import Path
-from typing import Set, List
+from typing import List, Dict, Iterable
 
 from bauh.gems.arch import pacman
 from bauh.gems.arch.model import ArchPackage
 
-RE_DESKTOP_ENTRY = re.compile(r'(Exec|Icon)\s*=\s*(.+)')
-RE_CLEAN_NAME = re.compile(r'^(\w+)-?|_?.+')
+RE_DESKTOP_ENTRY = re.compile(r'(Exec|Icon|NoDisplay)\s*=\s*(.+)')
+RE_CLEAN_NAME = re.compile(r'[+*?%]')
 
 
-def write(app: ArchPackage):
-    data = app.get_data_to_cache()
+def write(pkg: ArchPackage):
+    data = pkg.get_data_to_cache()
 
     if data:
-        Path(app.get_disk_cache_path()).mkdir(parents=True, exist_ok=True)
+        Path(pkg.get_disk_cache_path()).mkdir(parents=True, exist_ok=True)
 
-        with open(app.get_disk_data_path(), 'w+') as f:
+        with open(pkg.get_disk_data_path(), 'w+') as f:
             f.write(json.dumps(data))
 
 
-def fill_icon_path(app: ArchPackage, icon_paths: List[str], only_exact_match: bool):
-    ends_with = re.compile(r'.+/{}\.(png|svg|xpm)$'.format(app.icon_path if app.icon_path else app.name), re.IGNORECASE)
+def fill_icon_path(pkg: ArchPackage, icon_paths: List[str], only_exact_match: bool):
+    clean_name = RE_CLEAN_NAME.sub('', pkg.name)
+    ends_with = re.compile(r'.+/{}\.(png|svg|xpm)$'.format(pkg.icon_path if pkg.icon_path else clean_name), re.IGNORECASE)
 
     for path in icon_paths:
         if ends_with.match(path):
-            app.icon_path = path
+            pkg.icon_path = path
             return
 
     if not only_exact_match:
-        pkg_icons_path = pacman.list_icon_paths({app.name})
+        pkg_icons_path = pacman.list_icon_paths({pkg.name})
 
         if pkg_icons_path:
-            app.set_icon(pkg_icons_path)
+            pkg.set_icon(pkg_icons_path)
 
 
-def set_icon_path(app: ArchPackage, icon_name: str = None):
-    installed_icons = pacman.list_icon_paths({app.name})
+def set_icon_path(pkg: ArchPackage, icon_name: str = None):
+    installed_icons = pacman.list_icon_paths({pkg.name})
 
     if installed_icons:
-        exact_match = re.compile(r'.+/{}\..+$'.format(icon_name.split('.')[0] if icon_name else app.name))
+        exact_match = re.compile(r'.+/{}\..+$'.format(icon_name.split('.')[0] if icon_name else pkg.name))
         for icon_path in installed_icons:
             if exact_match.match(icon_path):
-                app.icon_path = icon_path
+                pkg.icon_path = icon_path
                 break
 
 
-def save_several(pkgnames: Set[str], mirror: str, overwrite: bool = True, maintainer: str = None, categories: dict = None) -> int:
-    to_cache = {n for n in pkgnames if overwrite or not os.path.exists(ArchPackage.disk_cache_path(n, mirror))}
+def save_several(pkgnames: Iterable[str], repo_map: Dict[str, str], overwrite: bool = True, maintainer: str = None,
+                 categories: dict = None, when_prepared=None, after_written=None) -> int:
+    if overwrite:
+        to_cache = pkgnames
+    else:
+        to_cache = {n for n in pkgnames if not os.path.exists(ArchPackage.disk_cache_path(n))}
+
     desktop_files = pacman.list_desktop_entries(to_cache)
 
-    no_desktop_files = {}
+    no_desktop_files = set()
 
     to_write = []
+
     if desktop_files:
         desktop_matches, no_exact_match = {}, set()
         for pkg in to_cache:  # first try to find exact matches
-            ends_with = re.compile('/usr/share/applications/{}.desktop$'.format(pkg), re.IGNORECASE)
+            try:
+                clean_name = RE_CLEAN_NAME.sub('', pkg)
+                ends_with = re.compile(r'/usr/share/applications/{}.desktop$'.format(clean_name), re.IGNORECASE)
+            except:
+                raise
 
             for f in desktop_files:
                 if ends_with.match(f):
@@ -88,23 +99,35 @@ def save_several(pkgnames: Set[str], mirror: str, overwrite: bool = True, mainta
             pkgs, apps_icons_noabspath = [], []
 
             for pkgname, file in desktop_matches.items():
-                p = ArchPackage(name=pkgname, mirror=mirror)
-                p.desktop_entry = file
+                p = ArchPackage(name=pkgname, repository=repo_map.get(pkgname))
 
                 with open(file) as f:
-                    desktop_entry = f.read()
+                    try:
+                        desktop_entry = f.read()
+                        p.desktop_entry = file
 
-                for field in RE_DESKTOP_ENTRY.findall(desktop_entry):
-                    if field[0] == 'Exec':
-                        p.command = field[1].strip().replace('"', '')
-                    elif field[0] == 'Icon':
-                        p.icon_path = field[1].strip()
+                        for field in RE_DESKTOP_ENTRY.findall(desktop_entry):
+                            if field[0] == 'Exec':
+                                p.command = field[1].strip().replace('"', '')
+                            elif field[0] == 'Icon':
+                                p.icon_path = field[1].strip()
 
-                        if p.icon_path and '/' not in p.icon_path:  # if the icon full path is not defined
-                            apps_icons_noabspath.append(p)
+                                if p.icon_path and '/' not in p.icon_path:  # if the icon full path is not defined
+                                    apps_icons_noabspath.append(p)
+                            elif field[0] == 'NoDisplay' and field[1].strip().lower() == 'true':
+                                p.command = None
+
+                                if p.icon_path:
+                                    apps_icons_noabspath.remove(p.icon_path)
+                                    p.icon_path = None
+                    except:
+                        continue
 
                 pkgs.append(p)
 
+                if when_prepared:
+                    when_prepared(p.name)
+
             if apps_icons_noabspath:
                 icon_paths = pacman.list_icon_paths({app.name for app in apps_icons_noabspath})
                 if icon_paths:
@@ -113,35 +136,54 @@ def save_several(pkgnames: Set[str], mirror: str, overwrite: bool = True, mainta
 
             for p in pkgs:
                 to_write.append(p)
+    else:
+        no_desktop_files = {*pkgnames}
 
     if no_desktop_files:
-        pkgs = {ArchPackage(name=n, mirror=mirror) for n in no_desktop_files}
         bin_paths = pacman.list_bin_paths(no_desktop_files)
+        icon_paths = pacman.list_icon_paths(no_desktop_files)
 
-        if bin_paths:
-            for p in pkgs:
-                ends_with = re.compile(r'.+/{}$'.format(p.name), re.IGNORECASE)
+        for n in no_desktop_files:
+            p = ArchPackage(name=n, repository=repo_map.get(n))
+
+            if bin_paths:
+                clean_name = RE_CLEAN_NAME.sub('', p.name)
+                ends_with = re.compile(r'.+/{}$'.format(clean_name), re.IGNORECASE)
 
                 for path in bin_paths:
                     if ends_with.match(path):
                         p.command = path
                         break
-
-        icon_paths = pacman.list_icon_paths(no_desktop_files)
-
-        if icon_paths:
-            for p in pkgs:
+            if icon_paths:
                 fill_icon_path(p, icon_paths, only_exact_match=True)
 
-        for p in pkgs:
             to_write.append(p)
 
+            if when_prepared:
+                when_prepared(p.name)
+
     if to_write:
+        written = set()
         for p in to_write:
             if categories:
                 p.categories = categories.get(p.name)
 
-            p.maintainer = maintainer
+            if maintainer and not p.maintainer:
+                p.maintainer = maintainer
+
             write(p)
+
+            if after_written:
+                after_written(p.name)
+
+            written.add(p.name)
+
+        if len(to_write) != len(to_cache):
+            for n in pkgnames:
+                if n not in written:
+                    Path(ArchPackage.disk_cache_path(n)).mkdir(parents=True, exist_ok=True)
+                    if after_written:
+                        after_written(n)
+
         return len(to_write)
     return 0

bauh/gems/arch/mapper.py

@@ -117,7 +117,7 @@ class ArchDataMapper:
 
     def map_api_data(self, apidata: dict, installed: dict, categories: dict) -> ArchPackage:
         data = installed.get(apidata.get('Name'))
-        app = ArchPackage(name=apidata.get('Name'), installed=bool(data), mirror='aur', i18n=self.i18n)
+        app = ArchPackage(name=apidata.get('Name'), installed=bool(data), repository='arch', i18n=self.i18n)
         app.status = PackageStatus.LOADING_DATA
 
         if categories:

bauh/gems/arch/message.py

@@ -1,22 +1,31 @@
+from typing import Iterable
+
 from bauh.api.abstract.handler import ProcessWatcher
 from bauh.api.abstract.view import MessageType
 from bauh.commons.html import bold
 from bauh.view.util.translation import I18n
 
 
-def show_dep_not_installed(watcher: ProcessWatcher, pkgname: str, depname: str, i18n: I18n):
-    watcher.show_message(title=i18n['error'],
-                         body=i18n['arch.install.dependency.install.error'].format(bold(depname), bold(pkgname)),
+def show_deps_not_installed(watcher: ProcessWatcher, pkgname: str, depnames: Iterable[str], i18n: I18n):
+    deps = ', '.join((bold(d) for d in depnames))
+    watcher.show_message(title=i18n['error'].capitalize(),
+                         body=i18n['arch.install.dependency.install.error'].format(deps, bold(pkgname)),
                          type_=MessageType.ERROR)
 
 
 def show_dep_not_found(depname: str, i18n: I18n, watcher: ProcessWatcher):
-    watcher.show_message(title=i18n['arch.install.dep_not_found.title'],
-                         body=i18n['arch.install.dep_not_found.body'].format(bold(depname)),
+
+    body = '<p>{}</p><p>{}</p><p></p><p>{}</p>'.format(i18n['arch.install.dep_not_found.body.l1'].format(bold(depname)),
+                                                       i18n['arch.install.dep_not_found.body.l2'],
+                                                       i18n['arch.install.dep_not_found.body.l3'])
+
+    watcher.show_message(title=i18n['arch.install.dep_not_found.title'].capitalize(),
+                         body=body,
                          type_=MessageType.ERROR)
 
 
-def show_optdep_not_installed(depname: str, watcher: ProcessWatcher, i18n: I18n):
-    watcher.show_message(title=i18n['error'],
-                         body=i18n['arch.install.optdep.error'].format(bold(depname)),
+def show_optdeps_not_installed(depnames: Iterable[str], watcher: ProcessWatcher, i18n: I18n):
+    deps = ', '.join((bold(d) for d in depnames))
+    watcher.show_message(title=i18n['error'].capitalize(),
+                         body=i18n['arch.install.optdep.error'].format(deps),
                          type_=MessageType.ERROR)

bauh/gems/arch/mirrors.py

@@ -0,0 +1,42 @@
+import logging
+import os
+import time
+import traceback
+from datetime import datetime
+from logging import Logger
+from pathlib import Path
+
+from bauh.api.constants import CACHE_PATH
+
+SYNC_FILE = '{}/arch/mirrors_sync'.format(CACHE_PATH)
+
+
+def should_sync(logger: logging.Logger):
+    if os.path.exists(SYNC_FILE):
+        with open(SYNC_FILE) as f:
+            sync_file = f.read()
+
+        try:
+            sync_time = datetime.fromtimestamp(int(sync_file))
+            now = datetime.now()
+
+            if now > sync_time and now.day != sync_time.day:
+                logger.info("Package databases synchronization out of date")
+            else:
+                msg = "Package databases already synchronized"
+                logger.info(msg)
+                return False
+        except:
+            logger.warning("Could not convert the database synchronization time from '{}".format(SYNC_FILE))
+            traceback.print_exc()
+    return True
+
+
+def register_sync(logger: Logger):
+    try:
+        Path('/'.join(SYNC_FILE.split('/')[0:-1])).mkdir(parents=True, exist_ok=True)
+        with open(SYNC_FILE, 'w+') as f:
+            f.write(str(int(time.time())))
+    except:
+        logger.error("Could not write to mirrors sync file '{}'".format(SYNC_FILE))
+        traceback.print_exc()

bauh/gems/arch/model.py

@@ -6,7 +6,7 @@ from bauh.commons import resource
 from bauh.gems.arch import ROOT_DIR, ARCH_CACHE_PATH
 from bauh.view.util.translation import I18n
 
-CACHED_ATTRS = {'command', 'icon_path', 'mirror', 'maintainer', 'desktop_entry', 'categories'}
+CACHED_ATTRS = {'command', 'icon_path', 'repository', 'maintainer', 'desktop_entry', 'categories'}
 
 
 class ArchPackage(SoftwarePackage):
@@ -14,7 +14,7 @@ class ArchPackage(SoftwarePackage):
     def __init__(self, name: str = None, version: str = None, latest_version: str = None, description: str = None,
                  package_base: str = None, votes: int = None, popularity: float = None,
                  first_submitted: datetime.datetime = None, last_modified: datetime.datetime = None,
-                 maintainer: str = None, url_download: str = None, pkgbuild: str = None, mirror: str = None,
+                 maintainer: str = None, url_download: str = None, pkgbuild: str = None, repository: str = None,
                  desktop_entry: str = None, installed: bool = False, srcinfo: dict = None, dependencies: Set[str] = None,
                  i18n: I18n = None):
 
@@ -22,12 +22,12 @@ class ArchPackage(SoftwarePackage):
         self.package_base = package_base
         self.votes = votes
         self.popularity = popularity
-        self.maintainer = maintainer
+        self.maintainer = maintainer if maintainer else (repository if repository != 'arch' else None)
         self.url_download = url_download
         self.first_submitted = first_submitted
         self.last_modified = last_modified
         self.pkgbuild = pkgbuild
-        self.mirror = mirror
+        self.repository = repository
         self.command = None
         self.icon_path = None
         self.downgrade_enabled = False
@@ -37,27 +37,31 @@ class ArchPackage(SoftwarePackage):
         self.i18n = i18n
 
     @staticmethod
-    def disk_cache_path(pkgname: str, mirror: str):
-        return ARCH_CACHE_PATH + '/installed/' + ('aur' if mirror == 'aur' else 'mirror') + '/' + pkgname
+    def disk_cache_path(pkgname: str):
+        return ARCH_CACHE_PATH + '/installed/' + pkgname
 
     def get_pkg_build_url(self):
         if self.package_base:
             return 'https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=' + self.package_base
 
     def has_history(self):
-        return self.installed
+        return self.installed and self.repository == 'arch'
 
     def has_info(self):
         return True
 
-    def can_be_installed(self):
-        return super(ArchPackage, self).can_be_installed() and self.url_download
+    def can_be_installed(self) -> bool:
+        if super(ArchPackage, self).can_be_installed():
+            return bool(self.url_download) if self.repository == 'arch' else True
 
     def can_be_downgraded(self):
-        return self.installed and self.downgrade_enabled
+        return self.installed and self.downgrade_enabled and self.repository == 'arch'
 
     def get_type(self):
-        return 'aur' if self.mirror == 'aur' else 'arch'
+        return 'arch' if self.repository == 'arch' else 'arch_repo'
+
+    def get_update_type(self):
+        return 'Arch - {}'.format('AUR' if self.repository == 'arch' else 'Repository')
 
     def get_default_icon_path(self) -> str:
         return self.get_type_icon_path()
@@ -66,7 +70,7 @@ class ArchPackage(SoftwarePackage):
         return self.icon_path
 
     def get_type_icon_path(self):
-        return resource.get_path('img/{}.svg'.format('arch' if self.mirror == 'aur' else 'mirror'), ROOT_DIR)
+        return resource.get_path('img/{}.svg'.format('arch' if self.get_type() == 'arch' else 'repo'), ROOT_DIR)
 
     def is_application(self):
         return self.can_be_run()
@@ -79,7 +83,7 @@ class ArchPackage(SoftwarePackage):
 
     def get_disk_cache_path(self) -> str:
         if self.name:
-            return self.disk_cache_path(self.name, self.mirror)
+            return self.disk_cache_path(self.name)
 
     def get_data_to_cache(self) -> dict:
         cache = {}
@@ -125,7 +129,10 @@ class ArchPackage(SoftwarePackage):
         return False
 
     def get_name_tooltip(self) -> str:
-        return '{} ( {}: {} )'.format(self.name, self.i18n['repository'], self.mirror)
+        return '{} ( {}: {} )'.format(self.name, self.i18n['repository'], self.repository)
+
+    def supports_backup(self) -> bool:
+        return True
 
     def __str__(self):
         return self.__repr__()

bauh/gems/arch/output.py

@@ -0,0 +1,109 @@
+import logging
+import time
+from threading import Thread
+
+from bauh.api.abstract.handler import ProcessWatcher
+from bauh.view.util.translation import I18n
+
+
+class TransactionStatusHandler(Thread):
+
+    def __init__(self, watcher: ProcessWatcher, i18n: I18n, npkgs: int, logger: logging.Logger, percentage: bool = True):
+        super(TransactionStatusHandler, self).__init__(daemon=True)
+        self.watcher = watcher
+        self.i18n = i18n
+        self.npkgs = npkgs
+        self.downloading = 0
+        self.upgrading = 0
+        self.installing = 0
+        self.outputs = []
+        self.work = True
+        self.logger = logger
+        self.percentage = percentage
+        self.accepted = {'checking keyring',
+                         'checking package integrity',
+                         'loading package files',
+                         'checking for file conflicts',
+                         'checking available disk space'}
+
+    def gen_percentage(self) -> str:
+        if self.percentage:
+            performed = self.downloading + self.upgrading + self.installing
+            return '({0:.2f}%) '.format((performed / (2 * self.npkgs)) * 100)
+        else:
+            return ''
+
+    def get_performed(self) -> int:
+        return self.upgrading + self.installing
+
+    def _handle(self, output: str) -> bool:
+        if output:
+            if output.startswith('downloading'):
+                if self.downloading < self.npkgs:
+                    perc = self.gen_percentage()
+                    self.downloading += 1
+
+                    self.watcher.change_substatus('{}[{}/{}] {} {}'.format(perc, self.downloading, self.npkgs,
+                                                                           self.i18n['downloading'].capitalize(), output.split(' ')[1].strip()))
+            elif output.startswith('upgrading'):
+                self.downloading = self.npkgs  # to avoid wrong numbers the packages are cached
+
+                if self.get_performed() < self.npkgs:
+                    perc = self.gen_percentage()
+                    self.upgrading += 1
+
+                    performed = self.upgrading + self.installing
+
+                    if performed <= self.npkgs:
+                        self.watcher.change_substatus('{}[{}/{}] {} {}'.format(perc, self.upgrading, self.npkgs,
+                                                                                self.i18n['manage_window.status.upgrading'].capitalize(), output.split(' ')[1].strip()))
+            elif output.startswith('installing'):
+                self.downloading = self.npkgs  # to avoid wrong numbers the packages are cached
+
+                if self.get_performed() < self.npkgs:
+                    perc = self.gen_percentage()
+                    self.installing += 1
+
+                    performed = self.upgrading + self.installing
+
+                    if performed <= self.npkgs:
+                        self.watcher.change_substatus('{}[{}/{}] {} {}'.format(perc, self.installing, self.npkgs,
+                                                                               self.i18n['manage_window.status.installing'].capitalize(),
+                                                                               output.split(' ')[1].strip()))
+            else:
+                substatus_found = False
+                lower_output = output.lower()
+                for msg in self.accepted:
+                    if lower_output.startswith(msg):
+                        self.watcher.change_substatus(self.i18n['arch.substatus.{}'.format(msg)].capitalize())
+                        substatus_found = True
+                        break
+
+                if not substatus_found:
+                    performed = self.get_performed()
+
+                    if performed == 0 and self.downloading > 0:
+                        self.watcher.change_substatus('')
+                    elif performed == self.npkgs:
+                        self.watcher.change_substatus(self.i18n['finishing'].capitalize())
+                        return False
+
+        return True
+
+    def handle(self, output: str):
+        self.outputs.append(output)
+
+    def stop_working(self):
+        self.work = False
+
+    def run(self):
+        self.logger.info("Starting")
+        while self.work:
+            if self.outputs:
+                output = self.outputs.pop()
+                if not self._handle(output):
+                    break
+            else:
+                time.sleep(0.005)
+
+        self.logger.info("Finished")

bauh/gems/arch/pacman.py

@@ -1,62 +1,70 @@
+import os
 import re
 from threading import Thread
-from typing import List, Set, Tuple
+from typing import List, Set, Tuple, Dict, Iterable
 
-from bauh.commons.system import run_cmd, new_subprocess, new_root_subprocess, SystemProcess, SimpleProcess
+from bauh.commons.system import run_cmd, new_subprocess, new_root_subprocess, SystemProcess, SimpleProcess, \
+    ProcessHandler
+from bauh.commons.util import size_to_byte
 from bauh.gems.arch.exceptions import PackageNotFoundException
 
 RE_DEPS = re.compile(r'[\w\-_]+:[\s\w_\-\.]+\s+\[\w+\]')
 RE_OPTDEPS = re.compile(r'[\w\._\-]+\s*:')
 RE_DEP_NOTFOUND = re.compile(r'error:.+\'(.+)\'')
 RE_DEP_OPERATORS = re.compile(r'[<>=]')
+RE_INSTALLED_FIELDS = re.compile(r'(Name|Description|Version|Validated By)\s*:\s*(.+)')
+RE_INSTALLED_SIZE = re.compile(r'Installed Size\s*:\s*([0-9,\.]+)\s(\w+)\n?', re.IGNORECASE)
+RE_UPDATE_REQUIRED_FIELDS = re.compile(r'(\bProvides\b|\bInstalled Size\b|\bConflicts With\b)\s*:\s(.+)\n')
+RE_REMOVE_TRANSITIVE_DEPS = re.compile(r'removing\s([\w\-_]+)\s.+required\sby\s([\w\-_]+)\n?')
 
 
-def is_enabled() -> bool:
-    res = run_cmd('which pacman')
+def is_available() -> bool:
+    res = run_cmd('which pacman', print_error=False)
     return res and not res.strip().startswith('which ')
 
 
-def get_repositories(pkgs: Set[str]) -> dict:
+def get_repositories(pkgs: Iterable[str]) -> dict:
     pkgre = '|'.join(pkgs).replace('+', r'\+').replace('.', r'\.')
 
     searchres = new_subprocess(['pacman', '-Ss', pkgre]).stdout
-    mirrors = {}
+    repositories = {}
 
     for line in new_subprocess(['grep', '-E', '.+/({}) '.format(pkgre)], stdin=searchres).stdout:
         if line:
             match = line.decode()
             for p in pkgs:
                 if p in match:
-                    mirrors[p] = match.split('/')[0]
+                    repositories[p] = match.split('/')[0]
 
-    not_found = {pkg for pkg in pkgs if pkg and pkg not in mirrors}
+    not_found = {pkg for pkg in pkgs if pkg and pkg not in repositories}
 
     if not_found:  # if there are some packages not found, try to find via the single method:
         for dep in not_found:
-            mirror_data = guess_repository(dep)
+            repo_data = guess_repository(dep)
 
-            if mirror_data:
-                mirrors[mirror_data[0]] = mirror_data[1]
+            if repo_data:
+                repositories[repo_data[0]] = repo_data[1]
 
-    return mirrors
+    return repositories
 
 
 def is_available_in_repositories(pkg_name: str) -> bool:
     return bool(run_cmd('pacman -Ss ' + pkg_name))
 
 
-def get_info(pkg_name) -> str:
-    return run_cmd('pacman -Qi ' + pkg_name)
+def get_info(pkg_name, remote: bool = False) -> str:
+    return run_cmd('pacman -{}i {}'.format('Q' if not remote else 'S', pkg_name))
 
 
-def get_info_list(pkg_name: str) -> List[tuple]:
-    info = get_info(pkg_name)
+def get_info_list(pkg_name: str, remote: bool = False) -> List[tuple]:
+    info = get_info(pkg_name, remote)
     if info:
         return re.findall(r'(\w+\s?\w+)\s*:\s*(.+(\n\s+.+)*)', info)
 
 
-def get_info_dict(pkg_name: str) -> dict:
-    info_list = get_info_list(pkg_name)
+def get_info_dict(pkg_name: str, remote: bool = False) -> dict:
+    list_attrs = {'depends on', 'required by'}
+    info_list = get_info_list(pkg_name, remote)
 
     if info_list:
         info_dict = {}
@@ -69,16 +77,12 @@ def get_info_dict(pkg_name: str) -> dict:
 
             if attr == 'optional deps' and info_dict[attr]:
                 info_dict[attr] = info_dict[attr].split('\n')
-            elif attr == 'depends on' and info_dict[attr]:
+            elif attr in list_attrs and info_dict[attr]:
                 info_dict[attr] = [d.strip() for d in info_dict[attr].split(' ') if d]
 
         return info_dict
 
 
-def list_installed() -> Set[str]:
-    return {out.decode().strip() for out in new_subprocess(['pacman', '-Qq']).stdout if out}
-
-
 def check_installed(pkg: str) -> bool:
     res = run_cmd('pacman -Qq ' + pkg, print_error=False)
     return bool(res)
@@ -88,55 +92,54 @@ def _fill_ignored(res: dict):
     res['pkgs'] = list_ignored_packages()
 
 
-def list_and_map_installed() -> dict:  # returns a dict with with package names as keys and versions as values
-    installed = new_subprocess(['pacman', '-Qq']).stdout  # retrieving all installed package names
-    allinfo = new_subprocess(['pacman', '-Qi'], stdin=installed).stdout  # retrieving all installed packages info
-
+def map_installed(repositories: bool = True, aur: bool = True) -> dict:  # returns a dict with with package names as keys and versions as values
     ignored = {}
-    thread_ignored = Thread(target=_fill_ignored, args=(ignored,))
+    thread_ignored = Thread(target=_fill_ignored, args=(ignored,), daemon=True)
     thread_ignored.start()
 
-    pkgs, current_pkg = {'mirrors': {}, 'not_signed': {}}, {}
-    for out in new_subprocess(['grep', '-E', '(Name|Description|Version|Validated By)'],
-                              stdin=allinfo).stdout:  # filtering only the Name and Validated By fields:
-        if out:
-            line = out.decode()
+    allinfo = run_cmd('pacman -Qi')
 
-            if line.startswith('Name'):
-                current_pkg['name'] = line.split(':')[1].strip()
-            elif line.startswith('Version'):
-                version = line.split(':')
-                current_pkg['version'] = version[len(version) - 1].strip()
-            elif line.startswith('Description'):
-                current_pkg['description'] = line.split(':')[1].strip()
-            elif line.startswith('Validated'):
+    pkgs = {'signed': {}, 'not_signed': {}}
+    current_pkg = {}
+    for idx, field_tuple in enumerate(RE_INSTALLED_FIELDS.findall(allinfo)):
+        if field_tuple[0].startswith('N'):
+            current_pkg['name'] = field_tuple[1].strip()
+        elif field_tuple[0].startswith('Ve'):
+            current_pkg['version'] = field_tuple[1].split(':')[-1].strip()
+        elif field_tuple[0].startswith('D'):
+            current_pkg['description'] = field_tuple[1].strip()
+        elif field_tuple[0].startswith('Va'):
+            if field_tuple[1].strip().lower() == 'none' and aur:
+                pkgs['not_signed'][current_pkg['name']] = current_pkg
+                del current_pkg['name']
+            elif repositories:
+                pkgs['signed'][current_pkg['name']] = current_pkg
+                del current_pkg['name']
 
-                if line.split(':')[1].strip().lower() == 'none':
-                    pkgs['not_signed'][current_pkg['name']] = {'version': current_pkg['version'],
-                                                               'description': current_pkg['description']}
+            current_pkg = {}
 
-                current_pkg = {}
-
-    if pkgs and pkgs.get('not_signed'):
+    if pkgs['signed'] or pkgs['not_signed']:
         thread_ignored.join()
 
         if ignored['pkgs']:
             to_del = set()
-            for pkg in pkgs['not_signed'].keys():
-                if pkg in ignored['pkgs']:
-                    to_del.add(pkg)
 
-            for pkg in to_del:
-                del pkgs['not_signed'][pkg]
+            for key in ('signed', 'not_signed'):
+                if pkgs.get(key):
+                    for pkg in pkgs[key].keys():
+                        if pkg in ignored['pkgs']:
+                            to_del.add(pkg)
 
+                for pkg in to_del:
+                    del pkgs[key][pkg]
     return pkgs
 
 
-def install_as_process(pkgpath: str, root_password: str, aur: bool, pkgdir: str = '.') -> SystemProcess:
-    if aur:
-        cmd = ['pacman', '-U', pkgpath, '--noconfirm']  # pkgpath = install file path
+def install_as_process(pkgpaths: Iterable[str], root_password: str, file: bool, pkgdir: str = '.') -> SystemProcess:
+    if file:
+        cmd = ['pacman', '-U', *pkgpaths, '--noconfirm']  # pkgpath = install file path
     else:
-        cmd = ['pacman', '-S', pkgpath, '--noconfirm']  # pkgpath = pkgname
+        cmd = ['pacman', '-S', *pkgpaths, '--noconfirm']  # pkgpath = pkgname
 
     return SystemProcess(new_root_subprocess(cmd, root_password, cwd=pkgdir), wrong_error_phrase='warning:')
 
@@ -261,20 +264,19 @@ def read_repository_from_info(name: str) -> str:
     if not_found:
         return
 
-    mirror = None
+    repository = None
 
     for o in new_subprocess(['grep', '-Po', "Repository\s+:\s+\K.+"], stdin=info.stdout).stdout:
         if o:
             line = o.decode().strip()
 
             if line:
-                mirror = line
+                repository = line
 
-    return mirror
+    return repository
 
 
 def guess_repository(name: str) -> Tuple[str, str]:
-
     if not name:
         raise Exception("'name' cannot be None or blank")
 
@@ -366,3 +368,474 @@ def get_version_for_not_installed(pkgname: str) -> str:
 
     if output:
         return output.split('\n')[0].split(' ')[1].strip()
+
+
+def map_repositories(pkgnames: Iterable[str] = None) -> Dict[str, str]:
+    info = run_cmd('pacman -Si {}'.format(' '.join(pkgnames) if pkgnames else ''), print_error=False, ignore_return_code=True)
+    if info:
+        repos = re.findall(r'(Name|Repository)\s*:\s*(.+)', info)
+
+        if repos:
+            return {repos[idx+1][1].strip(): repo_data[1].strip() for idx, repo_data in enumerate(repos) if idx % 2 == 0}
+
+    return {}
+
+
+def list_repository_updates() -> Dict[str, str]:
+    output = run_cmd('pacman -Qu')
+    res = {}
+    if output:
+        for line in output.split('\n'):
+            if line:
+                line_split = line.split(' ')
+                res[line_split[0]] = line_split[-1]
+    return res
+
+
+def map_sorting_data(pkgnames: List[str]) -> Dict[str, dict]:
+    allinfo = new_subprocess(['pacman', '-Qi', *pkgnames]).stdout
+
+    pkgs, current_pkg = {}, {}
+    mapped_attrs = 0
+    for out in new_subprocess(["grep", "-Po", "(Name|Provides|Depends On)\s*:\s*\K(.+)"], stdin=allinfo).stdout:
+        if out:
+            line = out.decode().strip()
+
+            if line:
+                if mapped_attrs == 0:
+                    current_pkg['name'] = line
+                elif mapped_attrs == 1:
+                    provides = set() if line == 'None' else set(line.split(' '))
+                    provides.add(current_pkg['name'])
+                    current_pkg['provides'] = provides
+                elif mapped_attrs == 2:
+                    current_pkg['depends'] = line.split(':')[1].strip()
+                    pkgs[current_pkg['name']] = current_pkg
+                    del current_pkg['name']
+
+                    mapped_attrs = 0
+                    current_pkg = {}
+    return pkgs
+
+
+def get_build_date(pkgname: str) -> str:
+    output = run_cmd('pacman -Qi {}'.format(pkgname))
+
+    if output:
+        bdate_line = [l for l in output.split('\n') if l.startswith('Build Date')]
+
+        if bdate_line:
+            return ':'.join(bdate_line[0].split(':')[1:]).strip()
+
+
+def search(words: str) -> Dict[str, dict]:
+    output = run_cmd('pacman -Ss ' + words)
+
+    if output:
+        found, current = {}, {}
+        for l in output.split('\n'):
+            if l:
+                if l.startswith(' '):
+                    current['description'] = l.strip()
+                    found[current['name']] = current
+                    del current['name']
+                    current = None
+                else:
+                    if current is None:
+                        current = {}
+
+                    repo_split = l.split('/')
+                    current['repository'] = repo_split[0]
+
+                    data_split = repo_split[1].split(' ')
+                    current['name'] = data_split[0]
+
+                    version = data_split[1].split(':')
+                    current['version'] = version[0] if len(version) == 1 else version[1]
+        return found
+
+
+def get_databases() -> Set[str]:
+    with open('/etc/pacman.conf') as f:
+        conf_str = f.read()
+
+    return {db for db in re.findall(r'[\n|\s]+\[(\w+)\]', conf_str) if db != 'options'}
+
+
+def can_refresh_mirrors() -> bool:
+    output = run_cmd('which pacman-mirrors', print_error=False)
+    return True if output else False
+
+
+def refresh_mirrors(root_password: str) -> SimpleProcess:
+    return SimpleProcess(cmd=['pacman-mirrors', '-g'], root_password=root_password)
+
+
+def update_mirrors(root_password: str, countries: List[str]) -> SimpleProcess:
+    return SimpleProcess(cmd=['pacman-mirrors', '-c', ','.join(countries)], root_password=root_password)
+
+
+def sort_fastest_mirrors(root_password: str, limit: int) -> SimpleProcess:
+    cmd = ['pacman-mirrors', '--fasttrack']
+
+    if limit > 0:
+        cmd.append(str(limit))
+
+    return SimpleProcess(cmd=cmd, root_password=root_password)
+
+
+def list_mirror_countries() -> List[str]:
+    output = run_cmd('pacman-mirrors -l')
+
+    if output:
+        return [c for c in output.split('\n') if c]
+
+
+def get_current_mirror_countries() -> List[str]:
+    output = run_cmd('pacman-mirrors -lc').strip()
+    return ['all'] if not output else [c for c in output.split('\n') if c]
+
+
+def is_mirrors_available() -> bool:
+    res = run_cmd('which pacman-mirrors', print_error=False)
+    return res and not res.strip().startswith('which ')
+
+
+def get_update_size(pkgs: List[str]) -> Dict[str, int]:  # bytes:
+    output = run_cmd('pacman -Si {}'.format(' '.join(pkgs)))
+
+    if output:
+        return {pkgs[idx]: size_to_byte(float(size[0]), size[1]) for idx, size in enumerate(RE_INSTALLED_SIZE.findall(output))}
+
+    return {}
+
+
+def get_installed_size(pkgs: List[str]) -> Dict[str, int]:  # bytes
+    output = run_cmd('pacman -Qi {}'.format(' '.join(pkgs)))
+
+    if output:
+        return {pkgs[idx]: size_to_byte(float(size[0]), size[1]) for idx, size in enumerate(RE_INSTALLED_SIZE.findall(output))}
+
+    return {}
+
+
+def upgrade_system(root_password: str) -> SimpleProcess:
+    return SimpleProcess(cmd=['pacman', '-Syyu', '--noconfirm'], root_password=root_password)
+
+
+def get_dependencies_to_remove(pkgs: Iterable[str], root_password: str) -> Dict[str, str]:
+    proc = SimpleProcess(cmd=['pacman', '-R', *pkgs, '--confirm'], root_password=root_password)
+    success, output = ProcessHandler().handle_simple(proc)
+
+    if not output:
+        return {}
+
+    return {t[1]: t[0] for t in RE_REMOVE_TRANSITIVE_DEPS.findall(output)}
+
+
+def fill_provided_map(key: str, val: str, output: dict):
+    current_val = output.get(key)
+
+    if current_val is None:
+        output[key] = {val}
+    else:
+        current_val.add(val)
+
+
+def map_provided(remote: bool = False, pkgs: Iterable[str] = None) -> Dict[str, Set[str]]:
+    output = run_cmd('pacman -{}i {}'.format('S' if remote else 'Q', ' '.join(pkgs) if pkgs else ''))
+
+    if output:
+        provided_map = {}
+        latest_name, latest_version, provided = None, None, False
+
+        for l in output.split('\n'):
+            if l:
+                if l[0] != ' ':
+                    line = l.strip()
+                    field_sep_idx = line.index(':')
+                    field = line[0:field_sep_idx].strip()
+                    val = line[field_sep_idx + 1:].strip()
+
+                    if field == 'Name':
+                        latest_name = val
+                    elif field == 'Version':
+                        latest_version = val.split('=')[0]
+                    elif field == 'Provides':
+                        fill_provided_map(latest_name, latest_name, provided_map)
+                        fill_provided_map('{}={}'.format(latest_name, latest_version), latest_name, provided_map)
+
+                        if val != 'None':
+                            for w in val.split(' '):
+                                if w:
+                                    word = w.strip()
+                                    fill_provided_map(word, latest_name, provided_map)
+
+                                    word_split = word.split('=')
+
+                                    if word_split[0] != word:
+                                        fill_provided_map(word_split[0], latest_name, provided_map)
+                        else:
+                            provided = True
+
+                    elif provided:
+                        latest_name = None
+                        latest_version = None
+                        provided = False
+
+                elif provided:
+                    for w in l.split(' '):
+                        if w:
+                            word = w.strip()
+                            fill_provided_map(word, latest_name, provided_map)
+
+                            word_split = word.split('=')
+
+                            if word_split[0] != word:
+                                fill_provided_map(word_split[0], latest_name, provided_map)
+
+        return provided_map
+
+
+def map_updates_data(pkgs: Iterable[str], files: bool = False) -> dict:
+    if files:
+        output = run_cmd('pacman -Qi -p {}'.format(' '.join(pkgs)))
+    else:
+        output = run_cmd('pacman -Si {}'.format(' '.join(pkgs)))
+
+    if output:
+        res = {}
+        latest_name = None
+        data = {'ds': None, 's': None, 'v': None, 'c': None, 'p': None, 'd': None, 'r': None}
+        latest_field = None
+
+        for l in output.split('\n'):
+            if l:
+                if l[0] != ' ':
+                    line = l.strip()
+                    field_sep_idx = line.index(':')
+                    field = line[0:field_sep_idx].strip()
+                    val = line[field_sep_idx + 1:].strip()
+
+                    if field == 'Repository':
+                        data['r'] = val
+                        latest_field = 'r'
+                    elif field == 'Name':
+                        latest_name = val
+                        latest_field = 'n'
+                    elif field == 'Version':
+                        data['v'] = val.split('=')[0]
+                        latest_field = 'v'
+                    elif field == 'Provides':
+                        latest_field = 'p'
+                        data['p'] = {latest_name, '{}={}'.format(latest_name, data['v'])}
+                        if val != 'None':
+                            for w in val.split(' '):
+                                if w:
+                                    word = w.strip()
+                                    data['p'].add(word)
+
+                                    word_split = word.split('=')
+
+                                    if word_split[0] != word:
+                                        data['p'].add(word_split[0])
+                    elif field == 'Depends On':
+                        val = val.strip()
+
+                        if val == 'None':
+                            data['d'] = None
+                        else:
+                            data['d'] = {w.strip().split(':')[0].strip() for w in val.split(' ') if w}
+                            latest_field = 'd'
+                    elif field == 'Conflicts With':
+                        if val == 'None':
+                            data['c'] = None
+                        else:
+                            data['c'] = {w.strip() for w in val.split(' ') if w}
+
+                        latest_field = 'c'
+                    elif field == 'Download Size':
+                        size = val.split(' ')
+                        data['ds'] = size_to_byte(float(size[0]), size[1])
+                        latest_field = 'ds'
+                    elif field == 'Installed Size':
+                        size = val.split(' ')
+                        data['s'] = size_to_byte(float(size[0]), size[1])
+                        latest_field = 's'
+                    elif latest_name and latest_field == 's':
+                        res[latest_name] = data
+                        latest_name = None
+                        latest_field = None
+                        data = {'ds': None, 's': None, 'c': None, 'p': None, 'd': None, 'r': None,  'v': None}
+                    else:
+                        latest_field = None
+
+                elif latest_field and latest_field in ('p', 'c', 'd'):
+                    if latest_field == 'p':
+                        for w in l.split(' '):
+                            if w:
+                                word = w.strip()
+                                data['p'].add(word)
+
+                                word_split = word.split('=')
+
+                                if word_split[0] != word:
+                                    data['p'].add(word_split[0])
+                    else:
+                        data[latest_field].update((w.strip() for w in l.split(' ') if w))
+
+        return res
+
+
+def list_installed_names() -> Set[str]:
+    return {p for p in run_cmd('pacman -Qq').split('\n') if p}
+
+
+def upgrade_several(pkgnames: Iterable[str], root_password: str) -> SystemProcess:
+    cmd = ['pacman', '-S', *pkgnames, '--noconfirm']
+    if root_password:
+        return SystemProcess(new_root_subprocess(cmd, root_password), wrong_error_phrase='warning:')
+    else:
+        return SystemProcess(new_subprocess(cmd), wrong_error_phrase='warning:')
+
+
+def remove_several(pkgnames: Iterable[str], root_password: str) -> SystemProcess:
+    cmd = ['pacman', '-R', *pkgnames, '--noconfirm']
+    if root_password:
+        return SystemProcess(new_root_subprocess(cmd, root_password), wrong_error_phrase='warning:')
+    else:
+        return SystemProcess(new_subprocess(cmd), wrong_error_phrase='warning:')
+
+
+def map_optional_deps(names: Iterable[str], remote: bool, not_installed: bool = False) -> Dict[str, Dict[str, str]]:
+    output = run_cmd('pacman -{}i {}'.format('S' if remote else 'Q', ' '.join(names)))
+
+    if output:
+        res = {}
+        latest_name, deps = None, None
+
+        for l in output.split('\n'):
+            if l:
+                if l[0] != ' ':
+                    line = l.strip()
+                    field_sep_idx = line.index(':')
+                    field = line[0:field_sep_idx].strip()
+
+                    if field == 'Name':
+                        val = line[field_sep_idx + 1:].strip()
+                        latest_name = val
+                    elif field == 'Optional Deps':
+                        val = line[field_sep_idx + 1:].strip()
+                        deps = {}
+                        if val != 'None':
+                            if ':' in val:
+                                dep_info = val.split(':')
+                                desc = dep_info[1].strip()
+
+                                if desc and not_installed and '[installed]' in desc:
+                                    continue
+
+                                deps[dep_info[0].strip()] = desc
+                            else:
+                                sev_deps = {dep.strip(): '' for dep in val.split(' ') if dep and (not not_installed or '[installed]' not in dep)}
+                                deps.update(sev_deps)
+                    elif latest_name and deps is not None:
+                        res[latest_name] = deps
+                        latest_name, deps = None, None
+
+                elif latest_name and deps is not None:
+                    if ':' in l:
+                        dep_info = l.split(':')
+                        desc = dep_info[1].strip()
+
+                        if desc and not_installed and '[installed]' in desc:
+                            continue
+
+                        deps[dep_info[0].strip()] = desc
+                    else:
+                        sev_deps = {dep.strip(): '' for dep in l.split(' ') if dep and (not not_installed or '[installed]' not in dep)}
+                        deps.update(sev_deps)
+
+        return res
+
+
+def get_cache_dir() -> str:
+    dir_pattern = re.compile(r'.*CacheDir\s*=\s*.+')
+
+    if os.path.exists('/etc/pacman.conf'):
+        with open('/etc/pacman.conf') as f:
+            config_str = f.read()
+
+        cache_dirs = []
+
+        for string in dir_pattern.findall(config_str):
+            if not string.strip().startswith('#'):
+                cache_dirs.append(string.split('=')[1].strip())
+
+        return cache_dirs[-1] if cache_dirs else '/var/cache/pacman/pkg/'
+
+
+def map_required_by(names: Iterable[str]) -> Dict[str, Set[str]]:
+    output = run_cmd('pacman -Qi {}'.format(' '.join(names)))
+
+    if output:
+        res = {}
+        latest_name, required = None, None
+
+        for l in output.split('\n'):
+            if l:
+                if l[0] != ' ':
+                    line = l.strip()
+                    field_sep_idx = line.index(':')
+                    field = line[0:field_sep_idx].strip()
+
+                    if field == 'Name':
+                        val = line[field_sep_idx + 1:].strip()
+                        latest_name = val
+                    elif field == 'Required By':
+                        val = line[field_sep_idx + 1:].strip()
+                        required = set()
+                        if val != 'None':
+                            required.update((d for d in val.split(' ') if d))
+
+                    elif latest_name and required is not None:
+                        res[latest_name] = required
+                        latest_name, required = None, None
+
+                elif latest_name and required is not None:
+                    required.update(required.update((d for d in l.strip().split(' ') if d)))
+
+        return res
+
+
+def map_conflicts_with(names: Iterable[str], remote: bool) -> Dict[str, Set[str]]:
+    output = run_cmd('pacman -{}i {}'.format('S' if remote else 'Q', ' '.join(names)))
+
+    if output:
+        res = {}
+        latest_name, conflicts = None, None
+
+        for l in output.split('\n'):
+            if l:
+                if l[0] != ' ':
+                    line = l.strip()
+                    field_sep_idx = line.index(':')
+                    field = line[0:field_sep_idx].strip()
+
+                    if field == 'Name':
+                        val = line[field_sep_idx + 1:].strip()
+                        latest_name = val
+                    elif field == 'Conflicts With':
+                        val = line[field_sep_idx + 1:].strip()
+                        conflicts = set()
+                        if val != 'None':
+                            conflicts.update((d for d in val.split(' ') if d))
+
+                    elif latest_name and conflicts is not None:
+                        res[latest_name] = conflicts
+                        latest_name, conflicts = None, None
+
+                elif latest_name and conflicts is not None:
+                    conflicts.update(conflicts.update((d for d in l.strip().split(' ') if d)))
+
+        return res

bauh/gems/arch/resources/img/repo.svg

@@ -14,7 +14,7 @@
    viewBox="0 0 512.00003 512"
    width="512"
    xml:space="preserve"
-   sodipodi:docname="mirror.svg"
+   sodipodi:docname="repo.svg"
    inkscape:version="0.92.4 5da689c313, 2019-01-14"><metadata
      id="metadata822"><rdf:RDF><cc:Work
          rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type

bauh/gems/arch/resources/locale/ca

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=Els paquets AUR són mantinguts per una comunitat d’usuaris independent. No hi ha cap garantia que funcionin o que no danyin el vostre sistema.
-gem.aur.install.warning=Els paquets AUR són mantinguts per una comunitat d’usuaris independent. No hi ha cap garantia que funcionin o que no danyin el vostre sistema.
-aur.info.architecture=arquitectura
-aur.info.architecture.any=qualsevol
-aur.info.build date=data de compilació
-aur.info.depends on=depèn
-aur.info.description=descripció
-aur.info.install date=fecha d’instal·lació
-aur.info.install reason=motiu de la instal·lació
-aur.info.install reason.explicitly installed=instal·lat explícitament
-aur.info.install script=script d’instal·lació
-aur.info.install script.no=cap
-aur.info.installed size=mida de la instal·lació
-aur.info.licenses=llicències
-aur.info.name=nom
-aur.info.optional deps=dependències opcionals
-aur.info.packager=empaquetador
-aur.info.packager.unknown packager=desconegut
-aur.info.url=url
-aur.info.version=versió
-aur.info.arch=arquitectura
-aur.info.arch.any=qualsevol
-aur.info.depends=depèn
-aur.info.pkgdesc=descripció
-aur.info.pkgname=nom
-aur.info.pkgrel=publicació
-aur.info.pkgver=versió
-aur.info.source=origen
-aur.info.optdepends=dependències opcionals
-aur.info.license=llicència
-aur.info.validpgpkeys=claus PGP válides
-aur.info.options=opcions
-aur.info.provides=proporciona
-aur.info.conflicts with=té un conflicte amb
-arch.install.conflict.popup.title=S’ha detectat un conflicte
-arch.install.conflict.popup.body=Les aplicacions {} estan en conflicte. Heu de desinstal·lar una per a instal·lar l’altra. Voleu continuar?
-arch.missing_deps.title=Dependències mancants
-arch.missing_deps.body=S’han d’instal·lar les {deps} dependències següents abans de continuar amb la instal·lació de {name}
+arch.action.db_locked.body.l1=The system's package database is locked.
+arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
+arch.action.db_locked.confirmation=Unlock and continue
+arch.action.db_locked.error=It was not possible to unlock the database.
+arch.action.db_locked.title=Database locked
+arch.aur.install.pgp.body=Per a instal·lar {} cal rebre les claus PGP següents
+arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
+arch.aur.install.pgp.sign_fail=No s’ha pogut rebre la clau PGP {}
+arch.aur.install.pgp.substatus=S’està rebent la clau PGP {}
+arch.aur.install.pgp.success=Claus PGP rebudes i signades
+arch.aur.install.pgp.title=Claus PGP necessàries
+arch.aur.install.unknown_key.receive_error=No s’ha pogut rebre la clau pública {}
+arch.aur.install.unknown_key.status=S’està rebent la clau pública {}
+arch.aur.install.unknown_key.title=Clau pública necessària
+arch.aur.install.validity_check.body=Alguns dels fitxers font necessaris per a la instal·lació de {} són malmesos.
+arch.aur.install.validity_check.proceed=Voleu continuar de totes maneres? ( no es recomana )
+arch.aur.install.validity_check.title=Problemes d’integritat {}
+arch.aur.install.verifying_pgp=S’estan comprovant les claus PGP
+arch.building.package=S’està compilant el paquet {}
+arch.checking.conflicts=S’està comprovant si hi ha conflictes amb {}
+arch.checking.deps=S’estan comprovant les dependències de {}
+arch.checking.missing_deps=Verificació de les dependències que falten de {}
+arch.clone=S’està clonant el dipòsit {} de l’AUR
+arch.config.aur=AUR packages
+arch.config.aur.tip=It allows to manage AUR packages
+arch.config.clean_cache=Elimina les versions antigues
+arch.config.clean_cache.tip=Si cal eliminar les versions antigues d'un paquet emmagatzemat al disc durant la desinstal·lació
+arch.config.mirrors_sort_limit=Mirrors sort limit
+arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
+arch.config.optimize=optimize
+arch.config.optimize.tip=La configuració optimitzada s'utilitzarà per fer més ràpida la instal·lació, actualització i reversió dels paquets, en cas contrari s'utilitzarà la configuració del sistema.
+arch.config.refresh_mirrors=Refresh mirrors on startup
+arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup ( or after a device reboot )
+arch.config.repos=Repositories packages
+arch.config.repos.tip=It allows to manage packages from the repositories set
+arch.config.sync_dbs=Synchronize packages databases
+arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the  first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
+arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
+arch.custom_action.clean_cache=Clean cache
+arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
+arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
+arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
+arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
+arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
+arch.custom_action.clean_cache.status=Cleaning cache
+arch.custom_action.clean_cache.success=Cache successfully cleaned !
+arch.custom_action.refresh_dbs=Synchronize package databases
+arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
+arch.custom_action.refresh_mirrors=Refresh mirrors
+arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
+arch.custom_action.refresh_mirrors.location.all=All
+arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
+arch.custom_action.refresh_mirrors.select_label=Check the desired locations
+arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
+arch.custom_action.refresh_mirrors.status.updating=Sorting mirrors by speed
+arch.custom_action.upgrade_system=Quick system upgrade
+arch.custom_action.upgrade_system.no_updates=There are no updates available
+arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
+arch.custom_action.upgrade_system.status=Upgrading system
+arch.custom_action.upgrade_system.substatus=Upgrading packages
+arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
+arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
+arch.custom_action.upgrade_system.success.line3=Restart now ?
+arch.dialog.providers.line1=There are multiple providers for some dependencies
+arch.dialog.providers.line2=Select those you want
 arch.downgrade.error=Error
 arch.downgrade.impossible=No s’ha pogut revertir la versió de {}
+arch.downgrade.install_older=S’està instal·lant la versió anterior
+arch.downgrade.reading_commits=S’estan llegint les revisions del dipòsit
+arch.downgrade.repo_pkg.no_versions=No s'ha trobat cap versió antiga al disc
+arch.downgrade.searching_stored=Cerqueu versions antigues al disc
+arch.downgrade.version_found=S’ha trobat la versió actual del paquet
+arch.downloading.package=S’està baixant el paquet
+arch.info.00_pkg_build=PKGBUILD
+arch.info.01_id=identificació
+arch.info.02_name=nom
+arch.info.03_description=descripció
+arch.info.03_version=versió
+arch.info.04_popularity=popularitat
+arch.info.05_votes=vots
+arch.info.06_package_base=paquet base
+arch.info.07_maintainer=mantenidor
+arch.info.08_first_submitted=presentar per primera vegada
+arch.info.09_last_modified=última modificació
+arch.info.10_url=descàrrega uRL
+arch.info.11_pkg_build_url=uRL PKGBUILD
+arch.info.12_makedepends=dependències de compilació
+arch.info.13_dependson=dependències d'instal·lació
+arch.info.13_pkg_build=PKGBUILD
+arch.info.14_installed_files=arxius instal·lats
+arch.info.14_optdepends=dependències opcionals
+arch.info.15_checkdepends=comprovació de dependències
+arch.info.arch=arc
+arch.info.arch.any=cap
+arch.info.architecture=arquitectura
+arch.info.architecture.any=cap
+arch.info.build date=data de creació
+arch.info.conflicts with=conflictes amb
+arch.info.depends=depèn
+arch.info.depends on=depén de
+arch.info.description=descripció
+arch.info.download size=Download size
+arch.info.install date=data d'instal·lació
+arch.info.install reason=instal·lar raó
+arch.info.install reason.explicitly installed=instal·lat de forma explícita
+arch.info.install reason.installed as a dependency for another package=la dependència d'un altre paquet
+arch.info.install script=script d'instal·lació
+arch.info.install script.no=no
+arch.info.installed files=arxius instal·lats
+arch.info.installed size=mida instal·lat
+arch.info.license=llicència
+arch.info.licenses=llicències
+arch.info.licenses.custom=costum
+arch.info.name=nom
+arch.info.optdepends=dependències opcionals
+arch.info.optional deps=dependències opcionals
+arch.info.optional for=per opcional
+arch.info.options=opcions
+arch.info.packager=empaquetador
+arch.info.packager.unknown packager=desconegut
+arch.info.pkgdesc=descripció
+arch.info.pkgname=nom
+arch.info.pkgrel=alliberament
+arch.info.pkgver=versió
+arch.info.provides=proporciona
+arch.info.replaces=substitueix
+arch.info.required by=requerit per
+arch.info.source=font
+arch.info.url=uRL
+arch.info.validated by=validat per
+arch.info.validated by.signature=signatura
+arch.info.validpgpkeys=Les claus PGP vàlids
+arch.info.version=versió
+arch.install.aur.root_error.body=No està permès instal·lar, actualitzar ni revaloritzar un paquet com a usuari root.
+arch.install.aur.root_error.title=No es permet l’acció
+arch.install.aur.unknown_key.body=Per a continuar amb la instal·lació de {} cal confiar en la clau pública següent {}
+arch.install.conflict.popup.body=Les aplicacions {} estan en conflicte. Heu de desinstal·lar una per a instal·lar l’altra. Voleu continuar?
+arch.install.conflict.popup.title=S’ha detectat un conflicte
+arch.install.dep_not_found.body.l1=No s’ha trobat la dependència requerida {} a l’AUR ni als dipòsits
+arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
+arch.install.dep_not_found.body.l3=S’ha cancel·lat la instal·lació.
+arch.install.dep_not_found.title=No s’ha trobat la dependència
+arch.install.dependency.install=S’està instal·lant el paquet depenent {}
+arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
+arch.install.optdep.error=Could not install the optional packages: {}
+arch.install.optdeps.request.body={} s’ha instal·lat correctament. Hi ha paquets opcionals associats que potser voldreu instal·lar
+arch.install.optdeps.request.help=Marqueu els que voleu
+arch.install.optdeps.request.title=Dependències opcionals
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=S’està instal·lant el paquet {}
+arch.makepkg.optimizing=Optimitzant la recopilació
+arch.missing_deps.body=S’han d’instal·lar les {deps} dependències següents abans de continuar amb la instal·lació de {name}
+arch.missing_deps.title=Dependències mancants
+arch.missing_deps_found=Dependències mancants per a {}
+arch.optdeps.checking=S’estan comprovant les dependències opcionals de {}
+arch.providers=providers
+arch.substatus.checking keyring=Checking keyring
+arch.substatus.checking package integrity=Checking packages integrity
+arch.substatus.loading package files=Loading package files
+arch.substatus.checking for file conflicts=Checking for conflicts
+arch.substatus.checking available disk space=Checking available disk space
+arch.sync_databases.substatus=Synchronizing package databases
+arch.sync_databases.substatus.error=It was not possible to synchronize the package database
+arch.task.disk_cache=Organitzen dades dels paquets instal·lats
+arch.task.disk_cache.indexed=Preparats
+arch.task.disk_cache.prepared=Llegits
+arch.task.disk_cache.reading=Determinant els paquets instal·lats
+arch.task.mirrors=Refreshing mirrors
+arch.task.optimizing=Optimizing {}
+arch.task.sync_databases.waiting=Waiting for mirrors refreshing
+arch.task.sync_sb.status=Actualitzen {}
+arch.uncompressing.package=S’està descomprimint el paquet
+arch.uninstall.clean_cached.error=No s'ha pogut eliminar {} versions antigues que es troba al disc
+arch.uninstall.clean_cached.substatus=Eliminació de versions antigues del disc
+arch.uninstall.required_by=No es pot desinstal·lar {} perquè és necessari per al funcionament dels paquets següents.
+arch.uninstall.required_by.advice=It is necessary to uninstall them as well to proceed.
+arch.uninstalling.conflict=S’està suprimint el paquet conflictiu {}
+arch.uninstalling.conflict.fail=No s’ha pogut desinstal·lar el paquet conflictiu {}
+arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
+arch.update_summary.conflict_between=Conflict between {} and {}
+arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
+arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
+arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
+arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
+arch.warning.disabled=Sembla que no s’ha instal·lat {}. No podreu gestionar paquets Arch/AUR.
+arch.warning.git=Sembla que no s’ha instal·lat {}. No podreu revertir les versions de paquets Arch/AUR.
+arch_repo.history.1_version=versió
+arch_repo.history.2_release=publicació
+arch_repo.history.3_date=data
 aur.history.1_version=versió
 aur.history.2_release=publicació
 aur.history.3_date=data
-arch.downloading.package=S’està baixant el paquet
-arch.uncompressing.package=S’està descomprimint el paquet
-arch.checking.deps=S’estan comprovant les dependències de {}
-arch.checking.missing_deps=Verificació de les dependències que falten de {}
-arch.missing_deps_found=Dependències mancants per a {}
-arch.building.package=S’està compilant el paquet {}
-arch.checking.conflicts=S’està comprovant si hi ha conflictes amb {}
-arch.installing.package=S’està instal·lant el paquet {}
-arch.uninstalling.conflict=S’està suprimint el paquet conflictiu {}
-arch.uninstalling.conflict.fail=No s’ha pogut desinstal·lar el paquet conflictiu {}
-arch.clone=S’està clonant el dipòsit {} de l’AUR
-arch.downgrade.reading_commits=S’estan llegint les revisions del dipòsit
-arch.downgrade.version_found=S’ha trobat la versió actual del paquet
-arch.downgrade.install_older=S’està instal·lant la versió anterior
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=nom
-aur.info.03_version=versió
-aur.info.03_description=descripció
-aur.info.04_popularity=popularitat
-aur.info.05_votes=vots
-aur.info.06_package_base=paquet base
-aur.info.07_maintainer=mantenidor
-aur.info.08_first_submitted=primer enviament
-aur.info.09_last_modified=darrera modificació
-aur.info.10_url=url de baixada
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=dependències de compilació
-aur.info.13_dependson=dependències d’instal·lació
-aur.info.14_optdepends=dependències opcionals
-aur.info.15_checkdepends=dependències de verificació
-aur.info.14_installed_files=Fitxers instal·lats
-arch.install.dep_not_found.title=No s’ha trobat la dependència
-arch.install.dep_not_found.body=No s’ha trobat la dependència requerida {} a l’AUR ni als servidors rèplica per defecte. S’ha cancel·lat la instal·lació.
-arch.install.dependency.install=S’està instal·lant el paquet depenent {}
-arch.install.dependency.install.error=No s’ha pogut instal·lar el paquet depenent {}. S’ha interromput la instal·lació de {}.
-arch.uninstall.required_by=No es pot desinstal·lar {} perquè és necessari per al funcionament dels paquets següents
-arch.uninstall.required_by.advice=Heu de desinstal·lar-los abans de desinstal·lar {}
-arch.install.optdeps.request.title=Dependències opcionals
-arch.install.optdeps.request.body={} s’ha instal·lat correctament. Hi ha paquets opcionals associats que potser voldreu instal·lar
-arch.install.optdeps.request.help=Marqueu els que voleu
-arch.install.optdep.error=No s’ha pogut instal·lar el paquet opcional {}
-arch.optdeps.checking=S’estan comprovant les dependències opcionals de {}
-arch.warning.disabled=Sembla que no s’ha instal·lat {}. No podreu gestionar paquets Arch/AUR.
-arch.warning.git=Sembla que no s’ha instal·lat {}. No podreu revertir les versions de paquets Arch/AUR.
-arch.aur.install.verifying_pgp=S’estan comprovant les claus PGP
-arch.aur.install.pgp.title=Claus PGP necessàries
-arch.aur.install.pgp.body=Per a instal·lar {} cal rebre les claus PGP següents
-arch.aur.install.pgp.substatus=S’està rebent la clau PGP {}
-arch.aur.install.pgp.success=Claus PGP rebudes i signades
-arch.aur.install.pgp.sign_fail=No s’ha pogut signar la clau PGP {}
-arch.aur.install.pgp.sign_fail=No s’ha pogut rebre la clau PGP {}
-arch.aur.install.unknown_key.title=Clau pública necessària
-arch.aur.install.unknown_key.status=S’està rebent la clau pública {}
-arch.aur.install.unknown_key.receive_error=No s’ha pogut rebre la clau pública {}
-arch.install.aur.unknown_key.body=Per a continuar amb la instal·lació de {} cal confiar en la clau pública següent {}
-arch.aur.install.validity_check.title=Problemes d’integritat {}
-arch.aur.install.validity_check.body=Alguns dels fitxers font necessaris per a la instal·lació de {} són malmesos.
-arch.aur.install.validity_check.proceed=Voleu continuar de totes maneres? ( no es recomana )
-arch.makepkg.optimizing=Optimitzant la recopilació
-arch.config.optimize=optimize
-arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation faster, otherwise the system settings will be used
-arch.config.trans_dep_check=Previous dependencies checking
-arch.config.trans_dep_check.tip=If all package dependencies should be verified before installation begins, otherwise they will be discovered during installation.
-arch.sync_databases.substatus=Synchronizing package databases
-arch.sync_databases.substatus.error=It was not possible to synchronize the package database
-arch.config.sync_dbs=Synchronize packages databases
-arch.config.sync_dbs.tip=Synchronizes the package databases once a day ( or after a device reboot ) before the first package installation, upgrade or downgrade. This option help to prevent errors during these operations.
-arch.config.simple_dep_check=Verificació de dependències simples
-arch.config.simple_dep_check.tip=Si només s'hauria d'utilitzar la verificació de dependència proporcionada per pacman abans d'instal·lar un paquet (més ràpid, però no sempre exacte). Si està desactivat, es farà una comprovació més completa (més lenta, però més precisa)
-arch.install.aur.root_error.title=No es permet l’acció
-arch.install.aur.root_error.body=No està permès instal·lar, actualitzar ni revaloritzar un paquet com a usuari root.
+gem.arch.info=Software packages available for distributions based on Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Dipòsit
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=Els paquets AUR són mantinguts per una comunitat d’usuaris independent. No hi ha cap garantia que funcionin o que no danyin el vostre sistema.

bauh/gems/arch/resources/locale/de

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=AUR Pakete werden von einer unabhängigen Nutzergemeinschaft geflegt. Es keine Garantie das sie funktionieren oder kein Schaden verursachen.
-gem.aur.install.warning=AUR Pakete werden von einer unabhängigen Nutzergemeinschaft geflegt. Es keine Garantie das sie funktionieren oder kein Schaden verursachen.
-arch.install.conflict.popup.title=Konflikt entdeckt
-arch.install.conflict.popup.body=Die Anwendungen {} können nicht gleichzeitig installiert sein. Du musst eine deinstallieren um die andere zu installieren. Fortfahren?
-arch.missing_deps.title=Fehlende Abhängigkeiten
-arch.missing_deps.body=Die folgenden {deps} Abhängigkeiten müssten installiert sein, bevor mit der {name} Installation fortgefahren werden kann
+arch.action.db_locked.body.l1=The system's package database is locked.
+arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
+arch.action.db_locked.confirmation=Unlock and continue
+arch.action.db_locked.error=It was not possible to unlock the database.
+arch.action.db_locked.title=Database locked
+arch.aur.install.pgp.body=Um {} zu installieren sind folgende PGP Schlüssel nötig
+arch.aur.install.pgp.receive_fail=PGP Schlüssel {} konnte nicht empfangen werden
+arch.aur.install.pgp.sign_fail=PGP Schlüssel {} konnte nicht signiert werden
+arch.aur.install.pgp.substatus=PGP Schlüssel {} holen
+arch.aur.install.pgp.success=PGP Schlüssel geholt und signiert
+arch.aur.install.pgp.title=PGP Schlüssel benötigt
+arch.aur.install.unknown_key.receive_error=Öffentlicher Schlüssel {} konnte nicht emfangen werden
+arch.aur.install.unknown_key.status=Öffentlichen Schlüssel {} emfangen
+arch.aur.install.unknown_key.title=Öffentlicher Schlüssel nötig
+arch.aur.install.validity_check.body=Einige der Source-Dateien für die Installation von {} sind korrupt.
+arch.aur.install.validity_check.proceed=Wollen Sie trotzdem fortfahren? ( nicht empfohlen )
+arch.aur.install.validity_check.title=Integritätsprobleme {}
+arch.aur.install.verifying_pgp=PGP Schlüssel überprüfen
+arch.building.package=Paket {} erstellen
+arch.checking.conflicts=Konflikte mit {} überprüfen
+arch.checking.deps={} Abhängigkeiten überprüfen
+arch.checking.missing_deps=Überprüfen der fehlenden Abhängigkeiten von {}
+arch.clone=AUR Repository {} wird kopiert
+arch.config.aur=AUR packages
+arch.config.aur.tip=It allows to manage AUR packages
+arch.config.clean_cache=Remove old versions
+arch.config.clean_cache.tip=Whether old versions of a package stored on disk should be removed during uninstall
+arch.config.mirrors_sort_limit=Mirrors sort limit
+arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
+arch.config.optimize=optimize
+arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation, upgrading and downgrading faster, otherwise the system settings will be used
+arch.config.refresh_mirrors=Refresh mirrors on startup
+arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup ( or after a device reboot )
+arch.config.repos=Repositories packages
+arch.config.repos.tip=It allows to manage packages from the repositories set
+arch.config.sync_dbs=Synchronize packages databases
+arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the  first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
+arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
+arch.custom_action.clean_cache=Clean cache
+arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
+arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
+arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
+arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
+arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
+arch.custom_action.clean_cache.status=Cleaning cache
+arch.custom_action.clean_cache.success=Cache successfully cleaned !
+arch.custom_action.refresh_dbs=Synchronize package databases
+arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
+arch.custom_action.refresh_mirrors=Refresh mirrors
+arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
+arch.custom_action.refresh_mirrors.location.all=All
+arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
+arch.custom_action.refresh_mirrors.select_label=Check the desired locations
+arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
+arch.custom_action.refresh_mirrors.status.updating=Sorting mirrors by speed
+arch.custom_action.upgrade_system=Quick system upgrade
+arch.custom_action.upgrade_system.no_updates=There are no updates available
+arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
+arch.custom_action.upgrade_system.status=Upgrading system
+arch.custom_action.upgrade_system.substatus=Upgrading packages
+arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
+arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
+arch.custom_action.upgrade_system.success.line3=Restart now ?
+arch.dialog.providers.line1=There are multiple providers for some dependencies
+arch.dialog.providers.line2=Select those you want
 arch.downgrade.error=Fehler
 arch.downgrade.impossible=Downgrade von {} ist nicht möglich
+arch.downgrade.install_older=Alte Version installieren
+arch.downgrade.reading_commits=Repository Commits lesen
+arch.downgrade.repo_pkg.no_versions=No old version found on disk
+arch.downgrade.searching_stored=Looking for old versions on disk
+arch.downgrade.version_found=Aktuelle Paketversion gefunden
+arch.downloading.package=Paket herunterladen
+arch.info.00_pkg_build=pkgbuild
+arch.info.01_id=Ich würde
+arch.info.02_name=Name
+arch.info.03_description=Beschreibung
+arch.info.03_version=Ausführung
+arch.info.04_popularity=Popularität
+arch.info.05_votes=Stimmen
+arch.info.06_package_base=Packungsbasis
+arch.info.07_maintainer=Maintainer
+arch.info.08_first_submitted=zuerst eingereicht
+arch.info.09_last_modified=zuletzt bearbeitet
+arch.info.10_url=url herunterladen
+arch.info.11_pkg_build_url=url PKGBUILD
+arch.info.12_makedepends=Kompilierungsabhängigkeiten
+arch.info.13_dependson=Installationsabhängigkeiten
+arch.info.13_pkg_build=pkgbuild
+arch.info.14_installed_files=installierte Dateien
+arch.info.14_optdepends=optional Abhängigkeiten
+arch.info.15_checkdepends=Überprüfung Abhängigkeiten
+arch.info.arch=Bogen
+arch.info.arch.any=irgendein
+arch.info.architecture=Architektur
+arch.info.architecture.any=irgendein
+arch.info.build date=Erstellungsdatum
+arch.info.conflicts with=Konflikte mit
+arch.info.depends=hängt davon ab
+arch.info.depends on=kommt drauf an
+arch.info.description=Beschreibung
+arch.info.download size=Download size
+arch.info.install date=Installationsdatum
+arch.info.install reason=installieren Grund
+arch.info.install reason.explicitly installed=explizit installiert
+arch.info.install reason.installed as a dependency for another package=Abhängigkeit von einem anderen Paket
+arch.info.install script=Installationsskript
+arch.info.install script.no=Nein
+arch.info.installed files=installierten Dateien
+arch.info.installed size=installierte Größe
+arch.info.license=Lizenz
+arch.info.licenses=Lizenzen
+arch.info.licenses.custom=Benutzerdefiniert
+arch.info.name=Name
+arch.info.optdepends=optional Abhängigkeiten
+arch.info.optional deps=optional Abhängigkeiten
+arch.info.optional for=optional für
+arch.info.options=Optionen
+arch.info.packager=Packager
+arch.info.packager.unknown packager=Unbekannt
+arch.info.pkgdesc=Beschreibung
+arch.info.pkgname=Name
+arch.info.pkgrel=Freisetzung
+arch.info.pkgver=Ausführung
+arch.info.provides=bietet
+arch.info.replaces=Ersetzt
+arch.info.required by=benötigt von
+arch.info.source=Quelle
+arch.info.url=url
+arch.info.validated by=bestätigt von
+arch.info.validated by.signature=Unterschrift
+arch.info.validpgpkeys=gültig PGP-Schlüssel
+arch.info.version=Ausführung
+arch.install.aur.root_error.body=It is not allowed to install, upgrade or downgrade a package as the root user
+arch.install.aur.root_error.title=Action not allowed
+arch.install.aur.unknown_key.body=Um mit der Installation von {} fortzufahren ist es nötig dem öffentlichen Schlüssel {} zu vertrauen
+arch.install.conflict.popup.body=Die Anwendungen {} können nicht gleichzeitig installiert sein. Du musst eine deinstallieren um die andere zu installieren. Fortfahren?
+arch.install.conflict.popup.title=Konflikt entdeckt
+arch.install.dep_not_found.body.l1=Nötige Abhängigkeit {} wurde weder im AUR noch in den standard Spiegelservern gefunden
+arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
+arch.install.dep_not_found.body.l3=Installation abgebrochen.
+arch.install.dep_not_found.title=Abhängigkeit nicht gefunden
+arch.install.dependency.install=Abhängigket {} wird installiert
+arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
+arch.install.optdep.error=Could not install the optional packages: {}
+arch.install.optdeps.request.body={} wurde erfolgreich installiert! Es gibt optionale zugehörige Pakete welche du vielleicht auch installieren möchtest
+arch.install.optdeps.request.help=Wähle entsprechende aus
+arch.install.optdeps.request.title=Optionale Abhängigkeiten
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=Paket {} installieren
+arch.makepkg.optimizing=Optimiert die Zusammenstellung
+arch.missing_deps.body=Die folgenden {deps} Abhängigkeiten müssten installiert sein, bevor mit der {name} Installation fortgefahren werden kann
+arch.missing_deps.title=Fehlende Abhängigkeiten
+arch.missing_deps_found=Fehlende Abhängigkeiten für {}
+arch.optdeps.checking={} optionale Abhängigkeiten überprüfen
+arch.providers=providers
+arch.substatus.checking keyring=Checking keyring
+arch.substatus.checking package integrity=Checking packages integrity
+arch.substatus.loading package files=Loading package files
+arch.substatus.checking for file conflicts=Checking for conflicts
+arch.substatus.checking available disk space=Checking available disk space
+arch.sync_databases.substatus=Synchronizing package databases
+arch.sync_databases.substatus.error=It was not possible to synchronize the package database
+arch.task.disk_cache=Organizing data from installed packages
+arch.task.disk_cache.indexed=Ready
+arch.task.disk_cache.prepared=Read
+arch.task.disk_cache.reading=Determining installed packages
+arch.task.mirrors=Refreshing mirrors
+arch.task.optimizing=Optimizing {}
+arch.task.sync_databases.waiting=Waiting for mirrors refreshing
+arch.task.sync_sb.status=Updating {}
+arch.uncompressing.package=Paket entpacken
+arch.uninstall.clean_cached.error=It was not possible to remove old {} versions found on disk
+arch.uninstall.clean_cached.substatus=Removing old versions from disk
+arch.uninstall.required_by={} konnte nicht deinstalliert werden, da es für die folgenden Pakete benötigt wird.
+arch.uninstall.required_by.advice=It is necessary to uninstall them as well to proceed.
+arch.uninstalling.conflict={} deinstallieren
+arch.uninstalling.conflict.fail=Deinstallation von {} fehlgeschlagen
+arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
+arch.update_summary.conflict_between=Conflict between {} and {}
+arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
+arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
+arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
+arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
+arch.warning.disabled={} scheint nicht intstalliert zu sein. Die Verwaltung von Arch / AUR Pakten wird nicht möglich sein.
+arch.warning.git={} scheint nicht installiert zu sein. Es wird nicht möglich sein, AUR Pakete zu downgraden.
+arch_repo.history.1_version=Version
+arch_repo.history.2_release=Release
+arch_repo.history.3_date=Datum
 aur.history.1_version=Version
 aur.history.2_release=Release
 aur.history.3_date=Datum
-arch.downloading.package=Paket herunterladen
-arch.uncompressing.package=Paket entpacken
-arch.checking.deps={} Abhängigkeiten überprüfen
-arch.checking.missing_deps=Überprüfen der fehlenden Abhängigkeiten von {}
-arch.missing_deps_found=Fehlende Abhängigkeiten für {}
-arch.building.package=Paket {} erstellen
-arch.checking.conflicts=Konflikte mit {} überprüfen
-arch.installing.package=Paket {} installieren
-arch.uninstalling.conflict={} deinstallieren
-arch.uninstalling.conflict.fail=Deinstallation von {} fehlgeschlagen
-arch.clone=AUR Repository {} wird kopiert
-arch.downgrade.reading_commits=Repository Commits lesen
-arch.downgrade.version_found=Aktuelle Paketversion gefunden
-arch.downgrade.install_older=Alte Version installieren
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=name
-aur.info.03_version=version
-aur.info.03_description=Beschreibung
-aur.info.04_popularity=Beliebtheit
-aur.info.05_votes=Stimmen
-aur.info.06_package_base=Paketbasis
-aur.info.07_maintainer=Maintainer
-aur.info.08_first_submitted=Erstmals veröffentlicht
-aur.info.09_last_modified=Zuletzt verändert
-aur.info.10_url=url zum Herunterladen
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=Kompilierungsabhängigkeiten
-aur.info.13_dependson=Installationsabhängigkeiten
-aur.info.14_optdepends=optionale Abhängigkeiten
-aur.info.15_checkdepends=Überprüfungsabhängigkeiten
-aur.info.14_installed_files=Installationsdateien
-arch.install.dep_not_found.title=Abhängigkeit nicht gefunden
-arch.install.dep_not_found.body=Nötige Abhängigkeit {} wurde weder im AUR noch in den standard Spiegelservern gefunden. Installation abgebrochen
-arch.install.dependency.install=Abhängigket {} wird installiert
-arch.install.dependency.install.error=Paket {} konnte nicht installiert werden. Installation von {} wurde abgebrochen.
-arch.uninstall.required_by={} konnte nicht deinstalliert werden, da es für die folgenden Pakete benötigt wird.
-arch.uninstall.required_by.advice=Deinstalliere sie zuerst, bevor du {} deinstalliert
-arch.install.optdeps.request.title=Optionale Abhängigkeiten
-arch.install.optdeps.request.body={} wurde erfolgreich installiert! Es gibt optionale zugehörige Pakete welche du vielleicht auch installieren möchtest
-arch.install.optdeps.request.help=Wähle entsprechende aus
-arch.install.optdep.error=Optionales Paket {} konnte nicht installiert werden
-arch.optdeps.checking={} optionale Abhängigkeiten überprüfen
-arch.warning.disabled={} scheint nicht intstalliert zu sein. Die Verwaltung von Arch / AUR Pakten wird nicht möglich sein.
-arch.warning.git={} scheint nicht installiert zu sein. Es wird nicht möglich sein, AUR Pakete zu downgraden.
-arch.aur.install.verifying_pgp=PGP Schlüssel überprüfen
-arch.aur.install.pgp.title=PGP Schlüssel benötigt
-arch.aur.install.pgp.body=Um {} zu installieren sind folgende PGP Schlüssel nötig
-arch.aur.install.pgp.substatus=PGP Schlüssel {} holen
-arch.aur.install.pgp.success=PGP Schlüssel geholt und signiert
-arch.aur.install.pgp.sign_fail=PGP Schlüssel {} konnte nicht signiert werden
-arch.aur.install.pgp.receive_fail=PGP Schlüssel {} konnte nicht empfangen werden
-arch.aur.install.unknown_key.title=Öffentlicher Schlüssel nötig
-arch.install.aur.unknown_key.body=Um mit der Installation von {} fortzufahren ist es nötig dem öffentlichen Schlüssel {} zu vertrauen
-arch.aur.install.unknown_key.status=Öffentlichen Schlüssel {} emfangen
-arch.aur.install.unknown_key.receive_error=Öffentlicher Schlüssel {} konnte nicht emfangen werden
-arch.aur.install.validity_check.title=Integritätsprobleme {}
-arch.aur.install.validity_check.body=Einige der Source-Dateien für die Installation von {} sind korrupt.
-arch.aur.install.validity_check.proceed=Wollen Sie trotzdem fortfahren? ( nicht empfohlen )
-aur.info.architecture=Architektur
-aur.info.architecture.any=beliebig
-aur.info.build date=Erstelldatum
-aur.info.depends on=Abhängigkeiten
-aur.info.description=Beschreibung
-aur.info.install date=Installationsdatum
-aur.info.install reason=Installationsgrund
-aur.info.install reason.explicitly installed=ausdrücklich installiert
-aur.info.install script=Installationsskript
-aur.info.install script.no=Nein
-aur.info.installed size=Installationsgröße
-aur.info.licenses=Lizenzen
-aur.info.name=Name
-aur.info.optional deps=optionale Abhängigkeiten
-aur.info.packager=Herausgeber
-aur.info.packager.unknown packager=unbekannt
-aur.info.url=url
-aur.info.version=Version
-aur.info.arch=Arch
-aur.info.arch.any=beliebig
-aur.info.depends=Abhängigkeiten
-aur.info.pkgdesc=Beschreibung
-aur.info.pkgname=Name
-aur.info.pkgrel=Veröffentlichung
-aur.info.pkgver=Version
-aur.info.source=Quellcode
-aur.info.optdepends=optionale Abhängigkeiten
-aur.info.license=Lizenz
-aur.info.validpgpkeys=gültige PGP Schlüssel
-aur.info.options=Optionen
-aur.info.provides=stellt bereit
-aur.info.conflicts with=Konflikt mit
-arch.makepkg.optimizing=Optimiert die Zusammenstellung
-arch.config.optimize=optimize
-arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation faster, otherwise the system settings will be used
-arch.config.trans_dep_check=Previous dependencies checking
-arch.config.trans_dep_check.tip=If all package dependencies should be verified before installation begins, otherwise they will be discovered during installation.
-arch.sync_databases.substatus=Synchronizing package databases
-arch.sync_databases.substatus.error=It was not possible to synchronize the package database
-arch.config.sync_dbs=Synchronize packages databases
-arch.config.sync_dbs.tip=Synchronizes the package databases once a day ( or after a device reboot ) before the first package installation, upgrade or downgrade. This option help to prevent errors during these operations.
-arch.config.simple_dep_check=Simple dependencies checking
-arch.config.simple_dep_check.tip=If only the dependency checking provided by pacman should be used before installing a package ( faster, but not always accurate ). If disabled, a more complete checking will be performed ( slower, but more accurate )
-arch.install.aur.root_error.title=Action not allowed
-arch.install.aur.root_error.body=It is not allowed to install, upgrade or downgrade a package as the root user
+gem.arch.info=Software packages available for distributions based on Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Repository
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=AUR Pakete werden von einer unabhängigen Nutzergemeinschaft geflegt. Es keine Garantie das sie funktionieren oder kein Schaden verursachen.

bauh/gems/arch/resources/locale/en

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=AUR packages are maintained by an independent user community. There is no warranty that they will work or not harm your system.
-gem.aur.install.warning=AUR packages are maintained by an independent user community. There is no warranty that they will work or not harm your system.
-arch.install.conflict.popup.title=Conflict detected
-arch.install.conflict.popup.body=The applications {} are in conflict. You must uninstall one to install the other. Continue ?
-arch.missing_deps.title=Missing dependencies
-arch.missing_deps.body=The following {deps} dependencies must be installed so the {name} installation can continue
+arch.action.db_locked.body.l1=The system's package database is locked.
+arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
+arch.action.db_locked.confirmation=Unlock and continue
+arch.action.db_locked.error=It was not possible to unlock the database.
+arch.action.db_locked.title=Database locked
+arch.aur.install.pgp.body=To install {} is necessary to receive the following PGP keys
+arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
+arch.aur.install.pgp.sign_fail=Could not sign PGP key {}
+arch.aur.install.pgp.substatus=Receiving PGP key {}
+arch.aur.install.pgp.success=PGP keys received and signed
+arch.aur.install.pgp.title=PGP keys required
+arch.aur.install.unknown_key.receive_error=Could not receive public key {}
+arch.aur.install.unknown_key.status=Receiving public key {}
+arch.aur.install.unknown_key.title=Public key required
+arch.aur.install.validity_check.body=Some of the source-files needed for {} installation are not healthy.
+arch.aur.install.validity_check.proceed=Do you want to continue anyway ? ( not recommended )
+arch.aur.install.validity_check.title=Integrity issues {}
+arch.aur.install.verifying_pgp=Verifying PGP keys
+arch.building.package=Building package {}
+arch.checking.conflicts=Checking any conflicts with {}
+arch.checking.deps=Checking {} dependencies
+arch.checking.missing_deps=Verifying missing dependencies of {}
+arch.clone=Cloning the AUR repository {}
+arch.config.aur=AUR packages
+arch.config.aur.tip=It allows to manage AUR packages
+arch.config.clean_cache=Remove old versions
+arch.config.clean_cache.tip=Whether old versions of a package stored on disk should be removed during uninstall
+arch.config.mirrors_sort_limit=Mirrors sort limit
+arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
+arch.config.optimize=optimize
+arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation, upgrading and downgrading faster, otherwise the system settings will be used
+arch.config.refresh_mirrors=Refresh mirrors on startup
+arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup ( or after a device reboot )
+arch.config.repos=Repositories packages
+arch.config.repos.tip=It allows to manage packages from the repositories set
+arch.config.sync_dbs=Synchronize packages databases
+arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the  first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
+arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
+arch.custom_action.clean_cache=Clean cache
+arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
+arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
+arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
+arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
+arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
+arch.custom_action.clean_cache.status=Cleaning cache
+arch.custom_action.clean_cache.success=Cache successfully cleaned !
+arch.custom_action.refresh_dbs=Synchronize package databases
+arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
+arch.custom_action.refresh_mirrors=Refresh mirrors
+arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
+arch.custom_action.refresh_mirrors.location.all=All
+arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
+arch.custom_action.refresh_mirrors.select_label=Check the desired locations
+arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
+arch.custom_action.refresh_mirrors.status.updating=Updating mirrors
+arch.custom_action.upgrade_system=Quick system upgrade
+arch.custom_action.upgrade_system.no_updates=There are no updates available
+arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
+arch.custom_action.upgrade_system.status=Upgrading system
+arch.custom_action.upgrade_system.substatus=Upgrading packages
+arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
+arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
+arch.custom_action.upgrade_system.success.line3=Restart now ?
+arch.dialog.providers.line1=There are multiple providers for some dependencies
+arch.dialog.providers.line2=Select those you want
 arch.downgrade.error=Error
 arch.downgrade.impossible=It is not possible to downgrade {}
+arch.downgrade.install_older=Installing older version
+arch.downgrade.reading_commits=Reading the repository commits
+arch.downgrade.repo_pkg.no_versions=No old version found on disk
+arch.downgrade.searching_stored=Looking for old versions on disk
+arch.downgrade.version_found=Current package version found
+arch.downloading.package=Downloading the package
+arch.info.00_pkg_build=pkgbuild
+arch.info.01_id=id
+arch.info.02_name=name
+arch.info.03_description=description
+arch.info.03_version=version
+arch.info.04_popularity=popularity
+arch.info.05_votes=votes
+arch.info.06_package_base=package base
+arch.info.07_maintainer=maintainer
+arch.info.08_first_submitted=first submitted
+arch.info.09_last_modified=last modified
+arch.info.10_url=url download
+arch.info.11_pkg_build_url=url pkgbuild
+arch.info.12_makedepends=compilation dependencies
+arch.info.13_dependson=installation dependencies
+arch.info.13_pkg_build=pkgbuild
+arch.info.14_installed_files=Installed files
+arch.info.14_optdepends=optional dependencies
+arch.info.15_checkdepends=checking dependencies
+arch.info.arch=arch
+arch.info.arch.any=any
+arch.info.architecture=architecture
+arch.info.architecture.any=any
+arch.info.build date=build date
+arch.info.conflicts with=conflicts with
+arch.info.depends=depends
+arch.info.depends on=depends on
+arch.info.description=description
+arch.info.download size=Download size
+arch.info.install date=install date
+arch.info.install reason=install reason
+arch.info.install reason.explicitly installed=explicitly installed
+arch.info.install reason.installed as a dependency for another package=dependency of another package
+arch.info.install script=install script
+arch.info.install script.no=no
+arch.info.installed files=installed files
+arch.info.installed size=installed size
+arch.info.license=license
+arch.info.licenses=licenses
+arch.info.licenses.custom=custom
+arch.info.name=name
+arch.info.optdepends=optional dependencies
+arch.info.optional deps=optional dependencies
+arch.info.optional for=optional for
+arch.info.options=options
+arch.info.packager=packager
+arch.info.packager.unknown packager=unknown
+arch.info.pkgdesc=description
+arch.info.pkgname=name
+arch.info.pkgrel=release
+arch.info.pkgver=version
+arch.info.provides=provides
+arch.info.replaces=replaces
+arch.info.required by=required by
+arch.info.source=source
+arch.info.url=url
+arch.info.validated by=validated by
+arch.info.validated by.signature=signature
+arch.info.validpgpkeys=valid PGP keys
+arch.info.version=version
+arch.install.aur.root_error.body=It is not allowed to install, upgrade or downgrade a package as the root user
+arch.install.aur.root_error.title=Action not allowed
+arch.install.aur.unknown_key.body=To continue {} installation is necessary to trust the following public key {}
+arch.install.conflict.popup.body=The applications {} are in conflict. You must uninstall one to install the other. Continue ?
+arch.install.conflict.popup.title=Conflict detected
+arch.install.dep_not_found.body.l1=Required dependency {} was not found in AUR nor in the repositories.
+arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
+arch.install.dep_not_found.body.l3=Installation cancelled.
+arch.install.dep_not_found.title=Dependency not found
+arch.install.dependency.install=Installing package dependency {}
+arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
+arch.install.optdep.error=Could not install the optional packages: {}
+arch.install.optdeps.request.body={} was succesfully installed ! There are some optional associated packages that you might want to install
+arch.install.optdeps.request.help=Check those you want
+arch.install.optdeps.request.title=Optional dependencies
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=Installing {} package
+arch.makepkg.optimizing=Optimizing the compilation
+arch.missing_deps.body=The following {deps} dependencies must be installed so the {name} installation can continue
+arch.missing_deps.title=Missing dependencies
+arch.missing_deps_found=Missing dependencies for {}
+arch.optdeps.checking=Checking {} optional dependencies
+arch.providers=providers
+arch.substatus.checking keyring=Checking keyring
+arch.substatus.checking package integrity=Checking packages integrity
+arch.substatus.loading package files=Loading package files
+arch.substatus.checking for file conflicts=Checking for conflicts
+arch.substatus.checking available disk space=Checking available disk space
+arch.sync_databases.substatus=Synchronizing package databases
+arch.sync_databases.substatus.error=It was not possible to synchronize the package database
+arch.task.disk_cache=Organizing data from installed packages
+arch.task.disk_cache.indexed=Ready
+arch.task.disk_cache.prepared=Read
+arch.task.disk_cache.reading=Determining installed packages
+arch.task.mirrors=Refreshing mirrors
+arch.task.optimizing=Optimizing {}
+arch.task.sync_databases.waiting=Waiting for mirrors refreshing
+arch.task.sync_sb.status=Updating {}
+arch.uncompressing.package=Uncompressing the package
+arch.uninstall.clean_cached.error=It was not possible to remove old {} versions found on disk
+arch.uninstall.clean_cached.substatus=Removing old versions from disk
+arch.uninstall.required_by={} cannot be uninstalled because it is required for the packages listed below to work.
+arch.uninstall.required_by.advice=It is necessary to uninstall them as well to proceed.
+arch.uninstalling.conflict=Uninstalling conflicting package {}
+arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting package {}
+arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
+arch.update_summary.conflict_between=Conflict between {} and {}
+arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
+arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
+arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
+arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
+arch.warning.disabled={} seems not to be installed. It will not be possible to manage Arch / AUR packages.
+arch.warning.git={} seems not to be installed. It will not be possible to downgrade AUR packages.
+arch_repo.history.1_version=version
+arch_repo.history.2_release=release
+arch_repo.history.3_date=date
 aur.history.1_version=version
 aur.history.2_release=release
 aur.history.3_date=date
-arch.downloading.package=Downloading the package
-arch.uncompressing.package=Uncompressing the package
-arch.checking.deps=Checking {} dependencies
-arch.missing_deps_found=Missing dependencies for {}
-arch.checking.missing_deps=Verifying missing dependencies of {}
-arch.building.package=Building package {}
-arch.checking.conflicts=Checking any conflicts with {}
-arch.installing.package=Installing {} package
-arch.uninstalling.conflict=Uninstalling conflicting package {}
-arch.uninstalling.conflict.fail=It was not possible to uninstall the conflicting package {}
-arch.clone=Cloning the AUR repository {}
-arch.downgrade.reading_commits=Reading the repository commits
-arch.downgrade.version_found=Current package version found
-arch.downgrade.install_older=Installing older version
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=name
-aur.info.03_version=version
-aur.info.03_description=description
-aur.info.04_popularity=popularity
-aur.info.05_votes=votes
-aur.info.06_package_base=package base
-aur.info.07_maintainer=maintainer
-aur.info.08_first_submitted=first submitted
-aur.info.09_last_modified=last modified
-aur.info.10_url=url download
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=compilation dependencies
-aur.info.13_dependson=installation dependencies
-aur.info.14_optdepends=optional dependencies
-aur.info.15_checkdepends=checking dependencies
-aur.info.14_installed_files=Installed files
-arch.install.dep_not_found.title=Dependency not found
-arch.install.dep_not_found.body=Required dependency {} was not found in AUR nor in default mirrors. Installation cancelled.
-arch.install.dependency.install=Installing package dependency {}
-arch.install.dependency.install.error=Could not install dependent package {}. Installation of {} aborted.
-arch.uninstall.required_by={} cannot be uninstalled because it is necessary for these following packages to work
-arch.uninstall.required_by.advice=Uninstall them first before uninstalling {}.
-arch.install.optdeps.request.title=Optional dependencies
-arch.install.optdeps.request.body={} was succesfully installed ! There are some optional associated packages that you might want to install
-arch.install.optdeps.request.help=Check those you want
-arch.install.optdep.error=Could not install the optional package {}
-arch.optdeps.checking=Checking {} optional dependencies
-arch.warning.disabled={} seems not to be installed. It will not be possible to manage Arch / AUR packages.
-arch.warning.git={} seems not to be installed. It will not be possible to downgrade AUR packages.
-arch.aur.install.verifying_pgp=Verifying PGP keys
-arch.aur.install.pgp.title=PGP keys required
-arch.aur.install.pgp.body=To install {} is necessary to receive the following PGP keys
-arch.aur.install.pgp.substatus=Receiving PGP key {}
-arch.aur.install.pgp.success=PGP keys received and signed
-arch.aur.install.pgp.sign_fail=Could not sign PGP key {}
-arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
-arch.aur.install.unknown_key.title=Public key required
-arch.install.aur.unknown_key.body=To continue {} installation is necessary to trust the following public key {}
-arch.aur.install.unknown_key.status=Receiving public key {}
-arch.aur.install.unknown_key.receive_error=Could not receive public key {}
-arch.aur.install.validity_check.title=Integrity issues {}
-arch.aur.install.validity_check.body=Some of the source-files needed for {} installation are not healthy.
-arch.aur.install.validity_check.proceed=Do you want to continue anyway ? ( not recommended )
-aur.info.architecture=architecture
-aur.info.architecture.any=any
-aur.info.build date=build date
-aur.info.depends on=depends on
-aur.info.description=description
-aur.info.install date=install date
-aur.info.install reason=install reason
-aur.info.install reason.explicitly installed=explicitly installed
-aur.info.install script=install script
-aur.info.install script.no=no
-aur.info.installed size=installed size
-aur.info.licenses=licenses
-aur.info.name=name
-aur.info.optional deps=optional deps
-aur.info.packager=packager
-aur.info.packager.unknown packager=unknown
-aur.info.url=url
-aur.info.version=version
-aur.info.arch=arch
-aur.info.arch.any=any
-aur.info.depends=depends
-aur.info.pkgdesc=description
-aur.info.pkgname=name
-aur.info.pkgrel=release
-aur.info.pkgver=version
-aur.info.source=source
-aur.info.optdepends=optionally depends
-aur.info.license=license
-aur.info.validpgpkeys=valid PGP keys
-aur.info.options=options
-aur.info.provides=provides
-aur.info.conflicts with=conflicts with
-arch.makepkg.optimizing=Optimizing the compilation
-arch.config.optimize=optimize
-arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation faster, otherwise the system settings will be used
-arch.config.trans_dep_check=Previous dependencies checking
-arch.config.trans_dep_check.tip=If all package dependencies should be verified before installation begins, otherwise they will be discovered during installation.
-arch.sync_databases.substatus=Synchronizing package databases
-arch.sync_databases.substatus.error=It was not possible to synchronize the package database
-arch.config.sync_dbs=Synchronize packages databases
-arch.config.sync_dbs.tip=Synchronizes the package databases once a day ( or after a device reboot ) before the first package installation, upgrade or downgrade. This option help to prevent errors during these operations.
-arch.config.simple_dep_check=Simple dependencies checking
-arch.config.simple_dep_check.tip=If only the dependency checking provided by pacman should be used before installing a package ( faster, but not always accurate ). If disabled, a more complete checking will be performed ( slower, but more accurate )
-arch.install.aur.root_error.title=Action not allowed
-arch.install.aur.root_error.body=It is not allowed to install, upgrade or downgrade a package as the root user
+gem.arch.info=Software packages available for distributions based on Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Repository
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=AUR packages are maintained by an independent user community. There is no warranty that they will work or not harm your system.

bauh/gems/arch/resources/locale/es

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=Los paquetes AUR son mantenidos por una comunidad de usuarios independiente. No hay garantía de que funcionen o que no dañen su sistema.
-gem.aur.install.warning=Los paquetes AUR son mantenidos por una comunidad de usuarios independiente. No hay garantía de que funcionen o que no dañen su sistema.
-aur.info.architecture=arquitectura
-aur.info.architecture.any=cualquier
-aur.info.build date=fecha de construcción
-aur.info.depends on=depende
-aur.info.description=descripción
-aur.info.install date=fecha de instalación
-aur.info.install reason=razón da instalación
-aur.info.install reason.explicitly installed=instalado explícitamente
-aur.info.install script=script de instalación
-aur.info.install script.no=ninguno
-aur.info.installed size=tamaño da instalación
-aur.info.licenses=licencias
-aur.info.name=nombre
-aur.info.optional deps=dependencias opcionales
-aur.info.packager=empaquetador
-aur.info.packager.unknown packager=desconocido
-aur.info.url=url
-aur.info.version=versión
-aur.info.arch=arquitectura
-aur.info.arch.any=cualquier
-aur.info.depends=depende
-aur.info.pkgdesc=descripción
-aur.info.pkgname=nombre
-aur.info.pkgrel=lanzamiento
-aur.info.pkgver=versión
-aur.info.source=origen
-aur.info.optdepends=dependencias opcionales
-aur.info.license=licencia
-aur.info.validpgpkeys=llaves PGP válidas
-aur.info.options=opciones
-aur.info.provides=provee
-aur.info.conflicts with=conflicta
-arch.install.conflict.popup.title=Conflicto detectado
-arch.install.conflict.popup.body=Los aplicativos {} estan en conflicto. Debe desinstalar uno para instalar el otro. ¿Continuar?
-arch.missing_deps.title=Dependencias faltantes
-arch.missing_deps.body=Deben instalarse las siguientes {deps} dependencias para que la instalación de {name} pueda continuar
+arch.action.db_locked.body.l1=La base de datos de paquetes del sistema está bloqueada.
+arch.action.db_locked.body.l2=Es necesario desbloquearla para continuar.
+arch.action.db_locked.confirmation=Desbloquear y continuar
+arch.action.db_locked.error=No fue posible desbloquear la base de datos.
+arch.action.db_locked.title=Base de dados bloqueada
+arch.aur.install.pgp.body=Para instalar {} es necesario recibir las siguientes claves PGP
+arch.aur.install.pgp.receive_fail=Could not receive PGP key {}
+arch.aur.install.pgp.sign_fail=No fue posible recibir la clave PGP {}
+arch.aur.install.pgp.substatus=Recibiendo clave PGP {}
+arch.aur.install.pgp.success=Claves PGP recibidas y firmadas
+arch.aur.install.pgp.title=Claves PGP necesarias
+arch.aur.install.unknown_key.receive_error=No fue posible recibir la clave pública {}
+arch.aur.install.unknown_key.status=Recibiendo la clave pública {}
+arch.aur.install.unknown_key.title=Clave pública necesaria
+arch.aur.install.validity_check.body=Algunos de los archivos fuente necesarios para la instalación de {} no están en buen estado.
+arch.aur.install.validity_check.proceed=¿Desea continuar de todos modos? ( no recomendado )
+arch.aur.install.validity_check.title=Problemas de integridad {}
+arch.aur.install.verifying_pgp=Verificando claves PGP
+arch.building.package=Construyendo el paquete {}
+arch.checking.conflicts=Verificando se hay conflictos con {}
+arch.checking.deps=Verificando las dependencias de {}
+arch.checking.missing_deps=Verificando las dependencias faltantes de {}
+arch.clone=Clonando el repositorio {} de AUR
+arch.config.aur=Paquetes de AUR
+arch.config.aur.tip=Permite gestionar paquetes del AUR
+arch.config.clean_cache=Eliminar versiones antiguas
+arch.config.clean_cache.tip=Si las versiones antiguas de un paquete almacenado en el disco deben ser eliminadas durante la desinstalación
+arch.config.mirrors_sort_limit=Límite de ordenación de espejos
+arch.config.mirrors_sort_limit.tip=Define el número máximo de espejos que se utilizarán para la ordenación por velocidad. Use 0 para no limitar o déjelo en blanco para deshabilitar la clasificación.
+arch.config.optimize=optimizar
+arch.config.optimize.tip=Se usará la configuración optimizada para que la instalación, actualización y reversión de los paquetes sean más rápidas, de lo contrario se usará la configuración del sistema
+arch.config.refresh_mirrors=Actualizar espejos al iniciar
+arch.config.refresh_mirrors.tip=Actualiza los espejos de paquetes una vez al día al iniciar ( o después de reiniciar el dispositivo )
+arch.config.repos=Paquetes de repositorios
+arch.config.repos.tip=Permite gestionar paquetes de los repositorios configurados
+arch.config.sync_dbs=Sincronizar las bases de paquetes
+arch.config.sync_dbs.tip=Sincroniza las bases de paquetes una vez al día antes de la primera instalación, actualización o reversión de paquete. Esta opción ayuda a prevenir errores durante estas operaciones.
+arch.config.sync_dbs_start.tip=Sincroniza las bases de paquetes durante la inicialización una vez al día
+arch.custom_action.clean_cache=Limpiar cache
+arch.custom_action.clean_cache.fail=Se produjo un error al limpiar el caché
+arch.custom_action.clean_cache.msg1=El caché es un directorio del sistema donde se almacenan los archivos de versiones anteriores de paquetes
+arch.custom_action.clean_cache.msg2=Limpiarlo libera espacio de almacenamiento sin dañar su sistema
+arch.custom_action.clean_cache.msg3=También ayuda cuando hay paquetes descargados con problemas de integridad que bloquean una acción
+arch.custom_action.clean_cache.no_dir=El directorio de cache {} no existe
+arch.custom_action.clean_cache.status=Limpiando cache
+arch.custom_action.clean_cache.success=Caché limpiado con éxito!
+arch.custom_action.refresh_dbs=Sincronizar bases de paquetes
+arch.custom_action.refresh_dbs.failed=No fue posible sincronizar las bases de paquete
+arch.custom_action.refresh_mirrors=Actualizar espejos
+arch.custom_action.refresh_mirrors.failed=No fue posible actualizar los espejos
+arch.custom_action.refresh_mirrors.location.all=Todas
+arch.custom_action.refresh_mirrors.location.all.tip=Si esta opción está marcada, las demás serán ignoradas.
+arch.custom_action.refresh_mirrors.select_label=Marcar las ubicaciones deseadas
+arch.custom_action.refresh_mirrors.status.sorting=Ordenando los espejos por velocidad
+arch.custom_action.refresh_mirrors.status.updating=Actualizando espejos
+arch.custom_action.upgrade_system=Actualización rápida de sistema
+arch.custom_action.upgrade_system.no_updates=No hay actualizaciones disponibles
+arch.custom_action.upgrade_system.pkgs=Los paquetes abajo serán actualizados
+arch.custom_action.upgrade_system.status=Actualizando sistema
+arch.custom_action.upgrade_system.substatus=Actualizando paquetes
+arch.custom_action.upgrade_system.success.line1=¡Sistema actualizado con éxito!
+arch.custom_action.upgrade_system.success.line2=Algunos cambios pueden requerir un reinicio del sistema para que surta efecto.
+arch.custom_action.upgrade_system.success.line3=¿Reiniciar ahora?
+arch.dialog.providers.line1=Hay múltiples proveedores para algunas dependencias
+arch.dialog.providers.line2=Seleccione las que desea
 arch.downgrade.error=Error
 arch.downgrade.impossible=No es posible revertir la versión de {}
+arch.downgrade.install_older=Instalando versión anterior
+arch.downgrade.reading_commits=Leyendo los commits del repositorio
+arch.downgrade.repo_pkg.no_versions=No se encontró una versión anterior en el disco
+arch.downgrade.searching_stored=Buscando versiones antiguas en el disco
+arch.downgrade.version_found=Version actual del paquete encontrada
+arch.downloading.package=Descargando el paquete
+arch.info.00_pkg_build=pkgbuild
+arch.info.01_id=id
+arch.info.02_name=nombre
+arch.info.03_description=descripción
+arch.info.03_version=versión
+arch.info.04_popularity=popularidad
+arch.info.05_votes=votos
+arch.info.06_package_base=paquete base
+arch.info.07_maintainer=mantenedor
+arch.info.08_first_submitted=primero envio
+arch.info.09_last_modified=última modificación
+arch.info.10_url=url para descarga
+arch.info.11_pkg_build_url=url pkgbuild
+arch.info.12_makedepends=dependencias para compilacion
+arch.info.13_dependson=dependencias para instalación
+arch.info.13_pkg_build=pkgbuild
+arch.info.14_installed_files=Archivos instalados
+arch.info.14_optdepends=dependencias opcionales
+arch.info.15_checkdepends=dependencias para verificación
+arch.info.arch=arquitectura
+arch.info.arch.any=cualquier
+arch.info.architecture=arquitectura
+arch.info.architecture.any=cualquier
+arch.info.build date=fecha de construcción
+arch.info.conflicts with=conflicta
+arch.info.depends=depende
+arch.info.depends on=depende de
+arch.info.description=descripción
+arch.info.download size=Tamaño de descarga
+arch.info.install date=fecha de instalación
+arch.info.install reason=razón da instalación
+arch.info.install reason.explicitly installed=instalado explícitamente
+arch.info.install reason.installed as a dependency for another package=dependencia de otro paquete
+arch.info.install script=script de instalación
+arch.info.install script.no=ninguno
+arch.info.installed files=archivos instalados
+arch.info.installed size=tamaño da instalación
+arch.info.license=licencia
+arch.info.licenses=licencias
+arch.info.licenses.custom=personalizada
+arch.info.name=nombre
+arch.info.optdepends=dependencias opcionales
+arch.info.optional deps=dependencias opcionales
+arch.info.optional for=opcional para
+arch.info.options=opciones
+arch.info.packager=empaquetador
+arch.info.packager.unknown packager=desconocido
+arch.info.pkgdesc=descripción
+arch.info.pkgname=nombre
+arch.info.pkgrel=lanzamiento
+arch.info.pkgver=versión
+arch.info.provides=provee
+arch.info.replaces=reemplaza
+arch.info.required by=requerido por
+arch.info.source=origen
+arch.info.url=url
+arch.info.validated by=validado por
+arch.info.validated by.signature=firma
+arch.info.validpgpkeys=llaves PGP válidas
+arch.info.version=versión
+arch.install.aur.root_error.body=No es permitido instalar, actualizar o revertir la versión de un paquete como usuario root
+arch.install.aur.root_error.title=Acción no permitida
+arch.install.aur.unknown_key.body=Para continuar la instalación de {} es necesario confiar en la siguiente clave pública {}
+arch.install.conflict.popup.body=Los aplicativos {} estan en conflicto. Debe desinstalar uno para instalar el otro. ¿Continuar?
+arch.install.conflict.popup.title=Conflicto detectado
+arch.install.dep_not_found.body.l1=No se encontró la dependencia requerida {} en AUR ni en los repositorios.
+arch.install.dep_not_found.body.l2=Puede ser un problema de sincronización de la base de paquetes.
+arch.install.dep_not_found.body.l3=Instalación cancelada.
+arch.install.dep_not_found.title=Dependencia no encontrada
+arch.install.dependency.install=Instalando el paquete dependiente {}
+arch.install.dependency.install.error=No se pudo instalar los paquetes dependientes: {}. Instalación de {} abortada.
+arch.install.optdep.error=No se pudo instalar los paquetes opcionales: {}
+arch.install.optdeps.request.body=¡{} se instaló correctamente! Hay algunos paquetes opcionales asociados que es posible que desee instalar
+arch.install.optdeps.request.help=Marque los que desee
+arch.install.optdeps.request.title=Dependencias opcionales
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=Instalando el paquete {}
+arch.makepkg.optimizing=Optimizing the compilation
+arch.missing_deps.body=Deben instalarse las siguientes {deps} dependencias para que la instalación de {name} pueda continuar
+arch.missing_deps.title=Dependencias faltantes
+arch.missing_deps_found=Dependencias faltantes para {}
+arch.optdeps.checking=Verificando las dependencias opcionales de {}
+arch.providers=proveedores
+arch.substatus.checking keyring=Verificando keyring
+arch.substatus.checking package integrity=Verificando la integridad de los paquetes
+arch.substatus.loading package files=Cargando archivos de los paquetes
+arch.substatus.checking for file conflicts=Verificando conflictos
+arch.substatus.checking available disk space=Verificando espacio disponible en disco
+arch.sync_databases.substatus=Sincronizando bases de paquetes
+arch.sync_databases.substatus.error=No fue posible sincronizar la base de paquetes
+arch.task.disk_cache=Organizando datos de paquetes instalados
+arch.task.disk_cache.indexed=Listos
+arch.task.disk_cache.prepared=Lidos
+arch.task.disk_cache.reading=Determinando los paquetes instalados
+arch.task.mirrors=Actualizando espejos
+arch.task.optimizing=Optimizando {}
+arch.task.sync_databases.waiting=Esperando por actualización de espejos
+arch.task.sync_sb.status=Actualizando {}
+arch.uncompressing.package=Descomprimindo el paquete
+arch.uninstall.clean_cached.error=No fue posible eliminar versiones antiguas de {} encontradas en disco
+arch.uninstall.clean_cached.substatus=Eliminando versiones antiguas del disco
+arch.uninstall.required_by=No se puede desinstalar {} porque es necesario para que los paquetes enumerados abajo funcionen.
+arch.uninstall.required_by.advice=Es necesario desinstalarlos también para continuar.
+arch.uninstalling.conflict=Eliminando el paquete conflictivo {}
+arch.uninstalling.conflict.fail=No fue posible desinstalar el paquete conflictivo {}
+arch.update.disabled.tooltip=Solo es posible actualizar este paquete a través de la acción "Actualización rápida de sistema"
+arch.update_summary.conflict_between=Conflicto entre {} y {}
+arch.update_summary.to_install.dep_conflict=Conflicto entre las dependencias {} y {}
+arch.update_summary.to_update.conflicts_dep=Conflicta con la dependencia {} de {}
+arch.update_summary.to_update.dep_conflicts=La dependencia {} conflicta con {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Actualizando paquetes de AUR
+arch.upgrade.upgrade_repo_pkgs=Actualizando paquetes de repositorios
+arch.warning.disabled={} parece no estar instalado. No será posible administrar paquetes Arch / AUR.
+arch.warning.git={} parece no estar instalado. No será posible revertir las versiones de paquetes Arch / AUR.
+arch_repo.history.1_version=versión
+arch_repo.history.2_release=lanzamiento
+arch_repo.history.3_date=fecha
 aur.history.1_version=versión
 aur.history.2_release=lanzamiento
 aur.history.3_date=fecha
-arch.downloading.package=Descargando el paquete
-arch.uncompressing.package=Descomprimindo el paquete
-arch.checking.deps=Verificando las dependencias de {}
-arch.checking.missing_deps=Verificando las dependencias faltantes de {}
-arch.missing_deps_found=Dependencias faltantes para {}
-arch.building.package=Construyendo el paquete {}
-arch.checking.conflicts=Verificando se hay conflictos con {}
-arch.installing.package=Instalando el paquete {}
-arch.uninstalling.conflict=Eliminando el paquete conflictivo {}
-arch.uninstalling.conflict.fail=No fue posible desinstalar el paquete conflictivo {}
-arch.clone=Clonando el repositorio {} de AUR
-arch.downgrade.reading_commits=Leyendo los commits del repositorio
-arch.downgrade.version_found=Version actual del paquete encontrada
-arch.downgrade.install_older=Instalando versión anterior
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=nombre
-aur.info.03_version=versión
-aur.info.03_description=descripción
-aur.info.04_popularity=popularidad
-aur.info.05_votes=votos
-aur.info.06_package_base=paquete base
-aur.info.07_maintainer=mantenedor
-aur.info.08_first_submitted=primero envio
-aur.info.09_last_modified=última modificación
-aur.info.10_url=url download
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=dependencias para compilacion
-aur.info.13_dependson=dependencias para instalación
-aur.info.14_optdepends=dependencias opcionales
-aur.info.15_checkdepends=dependencias para verificación
-aur.info.14_installed_files=Archivos instalados
-arch.install.dep_not_found.title=Dependencia no encontrada
-arch.install.dep_not_found.body=No se encontró la dependencia requerida {} en AUR ni en los espejos predeterminados. Instalación cancelada.
-arch.install.dependency.install=Instalando el paquete dependiente {}
-arch.install.dependency.install.error=No se pudo instalar el paquete dependiente {}. Instalación de {} abortada.
-arch.uninstall.required_by=No se puede desinstalar {} porque es necesario para que los siguientes paquetes funcionen
-arch.uninstall.required_by.advice=Debe desinstalarlos primero antes de desinstalar {}
-arch.install.optdeps.request.title=Dependencias opcionales
-arch.install.optdeps.request.body=¡{} se instaló correctamente! Hay algunos paquetes opcionales asociados que es posible que desee instalar
-arch.install.optdeps.request.help=Marque los que desee
-arch.install.optdep.error=No se pudo instalar el paquete opcional {}
-arch.optdeps.checking=Verificando las dependencias opcionales de {}
-arch.warning.disabled={} parece no estar instalado. No será posible administrar paquetes Arch / AUR.
-arch.warning.git={} parece no estar instalado. No será posible revertir las versiones de paquetes Arch / AUR.
-arch.aur.install.verifying_pgp=Verificando claves PGP
-arch.aur.install.pgp.title=Claves PGP necesarias
-arch.aur.install.pgp.body=Para instalar {} es necesario recibir las siguientes claves PGP
-arch.aur.install.pgp.substatus=Recibiendo clave PGP {}
-arch.aur.install.pgp.success=Claves PGP recibidas y firmadas
-arch.aur.install.pgp.sign_fail=No fue posible firmar la clave PGP {}
-arch.aur.install.pgp.sign_fail=No fue posible recibir la clave PGP {}
-arch.aur.install.unknown_key.title=Clave pública necesaria
-arch.aur.install.unknown_key.status=Recibiendo la clave pública {}
-arch.aur.install.unknown_key.receive_error=No fue posible recibir la clave pública {}
-arch.install.aur.unknown_key.body=Para continuar la instalación de {} es necesario confiar en la siguiente clave pública {}
-arch.aur.install.validity_check.title=Problemas de integridad {}
-arch.aur.install.validity_check.body=Algunos de los archivos fuente necesarios para la instalación de {} no están en buen estado.
-arch.aur.install.validity_check.proceed=¿Desea continuar de todos modos? ( no recomendado )
-arch.makepkg.optimizing=Optimizando la compilación
-arch.config.optimize=optimizar
-arch.config.optimize.tip=Se usará una configuración optimizada para acelerar la instalación de los paquetes, de lo contrario se usará la configuración del sistema
-arch.config.trans_dep_check=Verificación de dependencias anterior
-arch.config.trans_dep_check.tip=Si todas las dependencias del paquete deben ser verificadas antes de que comience la instalación, de lo contrario, se descubrirán durante la instalación.
-arch.sync_databases.substatus=Sincronizando bases de paquetes
-arch.sync_databases.substatus.error=No fue posible sincronizar la base de paquetes
-arch.config.sync_dbs=Sincronizar las bases de paquetes
-arch.config.sync_dbs.tip=Sincroniza las bases de paquetes una vez al día ( o cada reinicialización del dispositivo ) antes de la primera instalación, actualización o reversión de un paquete. Esta opción ayuda a prevenir errores durante estas operaciones.
-arch.config.simple_dep_check=Verificación de dependencias simples
-arch.config.simple_dep_check.tip=Si solo se usara la verificación de dependencia provista por pacman antes de instalar un paquete (más rápido, pero no siempre exacto). Si está deshabilitado, se realizará una verificación más completa (más lenta, pero más precisa)
-arch.install.aur.root_error.title=Acción no permitida
-arch.install.aur.root_error.body=No es permitido instalar, actualizar o revertir la versión de un paquete como usuario root
+gem.arch.info=Paquetes de software disponibles para distribuciones basadas en Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Repositorio
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=Los paquetes AUR son mantenidos por una comunidad de usuarios independiente. No hay garantía de que funcionen o que no dañen su sistema.

bauh/gems/arch/resources/locale/it

@@ -1,85 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=I pacchetti AUR sono gestiti da una comunità di utenti indipendenti. Non esiste alcuna garanzia che funzionino o non danneggino il sistema.
-gem.aur.install.warning=I pacchetti AUR sono gestiti da una comunità di utenti indipendenti. Non esiste alcuna garanzia che funzionino o non danneggino il sistema.
-arch.install.conflict.popup.title=Conflitto rilevato
-arch.install.conflict.popup.body=Le applicazioni {} sono in conflitto. È necessario disinstallarne una per installare l'altra. Continua ?
-arch.missing_deps.title=Dipendenze mancanti
-arch.missing_deps.body=Le seguenti {deps} dipendenze devono essere installate prima che l'installazione di {name} continui
+arch.action.db_locked.body.l1=The system's package database is locked.
+arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
+arch.action.db_locked.confirmation=Unlock and continue
+arch.action.db_locked.error=It was not possible to unlock the database.
+arch.action.db_locked.title=Database locked
+arch.aur.install.pgp.body=Per installare {} è necessario ricevere le seguenti chiavi PGP
+arch.aur.install.pgp.receive_fail=Impossibile ricevere la chiave PGP {}
+arch.aur.install.pgp.sign_fail=Impossibile firmare la chiave PGP {}
+arch.aur.install.pgp.substatus=Ricezione della chiave PGP {}
+arch.aur.install.pgp.success=Chiavi PGP ricevute e firmate
+arch.aur.install.pgp.title=Chiavi PGP richieste
+arch.aur.install.unknown_key.receive_error=Impossibile ricevere la chiave pubblica {}
+arch.aur.install.unknown_key.status=Ricezione della chiave pubblica {}
+arch.aur.install.unknown_key.title=Chiave pubblica richiesta
+arch.aur.install.validity_check.body=Alcuni dei file di origine necessari per l'installazione di {} non sono integri.
+arch.aur.install.validity_check.proceed=Vuoi continuare comunque? ( non consigliato )
+arch.aur.install.validity_check.title=Problemi di integrità {}
+arch.aur.install.verifying_pgp=Verifica chiavi PGP
+arch.building.package=Pacchetto costruito {}
+arch.checking.conflicts=Verifica di eventuali conflitti con {}
+arch.checking.deps=Verifica di {} dipendenze
+arch.checking.missing_deps=Verifica delle dipendenze mancanti di {}
+arch.clone=Clonazione del repository AUR {}
+arch.config.aur=AUR packages
+arch.config.aur.tip=It allows to manage AUR packages
+arch.config.clean_cache=Rimuovi le vecchie versioni
+arch.config.clean_cache.tip=Se le vecchie versioni di un pacchetto memorizzate sul disco devono essere rimosse durante la disinstallazione
+arch.config.mirrors_sort_limit=Mirrors sort limit
+arch.config.mirrors_sort_limit.tip=Defines the maximum number of mirrors that will be used for speed sorting. Use 0 for no limit or leave it blank to disable sorting.
+arch.config.optimize=optimize
+arch.config.optimize.tip=Verranno utilizzate le impostazioni ottimizzate per velocizzare l'installazione, l'aggiornamento e l'inversione dei pacchetti, altrimenti verranno utilizzate le impostazioni di sistema
+arch.config.refresh_mirrors=Refresh mirrors on startup
+arch.config.refresh_mirrors.tip=Refresh the package mirrors once a day on startup ( or after a device reboot )
+arch.config.repos=Repositories packages
+arch.config.repos.tip=It allows to manage packages from the repositories set
+arch.config.sync_dbs=Synchronize packages databases
+arch.config.sync_dbs.tip=Synchronizes the package databases once a day before the  first package installation, upgrade or downgrade. This option helps to prevent errors during these operations.
+arch.config.sync_dbs_start.tip=Synchronizes the package databases during the initialization once a day
+arch.custom_action.clean_cache=Clean cache
+arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
+arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
+arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
+arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
+arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
+arch.custom_action.clean_cache.status=Cleaning cache
+arch.custom_action.clean_cache.success=Cache successfully cleaned !
+arch.custom_action.refresh_dbs=Synchronize package databases
+arch.custom_action.refresh_dbs.failed=It was not possible to synchronize the package databases
+arch.custom_action.refresh_mirrors=Refresh mirrors
+arch.custom_action.refresh_mirrors.failed=It was not possible to refresh the mirrors
+arch.custom_action.refresh_mirrors.location.all=All
+arch.custom_action.refresh_mirrors.location.all.tip=If this option is checked, the others will be ignored.
+arch.custom_action.refresh_mirrors.select_label=Check the desired locations
+arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
+arch.custom_action.refresh_mirrors.status.updating=Sorting mirrors by speed
+arch.custom_action.upgrade_system=Quick system upgrade
+arch.custom_action.upgrade_system.no_updates=There are no updates available
+arch.custom_action.upgrade_system.pkgs=The packages below will be upgraded
+arch.custom_action.upgrade_system.status=Upgrading system
+arch.custom_action.upgrade_system.substatus=Upgrading packages
+arch.custom_action.upgrade_system.success.line1=System successfully upgraded!
+arch.custom_action.upgrade_system.success.line2=Some changes may require a system restart to take effect.
+arch.custom_action.upgrade_system.success.line3=Restart now ?
+arch.dialog.providers.line1=There are multiple providers for some dependencies
+arch.dialog.providers.line2=Select those you want
 arch.downgrade.error=Errore
 arch.downgrade.impossible=Non è possibile effettuare il downgrade {}
+arch.downgrade.install_older=Installazione della versione precedente
+arch.downgrade.reading_commits=Reading the repository commits
+arch.downgrade.repo_pkg.no_versions=Nessuna versione precedente trovata sul disco
+arch.downgrade.searching_stored=Ricerca di versioni precedenti su disco
+arch.downgrade.version_found=Trovata la versione del pacchetto corrente
+arch.downloading.package=Download del pacchetto
+arch.info.00_pkg_build=pkgbuild
+arch.info.01_id=id
+arch.info.02_name=nome
+arch.info.03_description=descrizione
+arch.info.03_version=versione
+arch.info.04_popularity=popolarità
+arch.info.05_votes=voti
+arch.info.06_package_base=pacchetto base
+arch.info.07_maintainer=manutentore
+arch.info.08_first_submitted=prima presentata
+arch.info.09_last_modified=Ultima modifica
+arch.info.10_url=URL per il download
+arch.info.11_pkg_build_url=url PKGBUILD
+arch.info.12_makedepends=le dipendenze di compilazione
+arch.info.13_dependson=dipendenze di installazione
+arch.info.13_pkg_build=pkgbuild
+arch.info.14_installed_files=file installati
+arch.info.14_optdepends=dipendenze opzionali
+arch.info.15_checkdepends=il controllo delle dipendenze
+arch.info.arch=arco
+arch.info.arch.any=qualunque
+arch.info.architecture=architettura
+arch.info.architecture.any=qualunque
+arch.info.build date=data di costruzione
+arch.info.conflicts with=conflitti con
+arch.info.depends=dipende
+arch.info.depends on=dipende da
+arch.info.description=descrizione
+arch.info.download size=Download size
+arch.info.install date=data di installazione
+arch.info.install reason=installare ragione
+arch.info.install reason.explicitly installed=esplicitamente installato
+arch.info.install reason.installed as a dependency for another package=dipendenza di un altro pacchetto
+arch.info.install script=script di installazione
+arch.info.install script.no=nessuno
+arch.info.installed files=file installati
+arch.info.installed size=taglia installata
+arch.info.license=licenza
+arch.info.licenses=licenze
+arch.info.licenses.custom=costume
+arch.info.name=nome
+arch.info.optdepends=dipendenze opzionali
+arch.info.optional deps=dipendenze opzionali
+arch.info.optional for=per facoltativo
+arch.info.options=opzioni
+arch.info.packager=packager
+arch.info.packager.unknown packager=sconosciuto
+arch.info.pkgdesc=descrizione
+arch.info.pkgname=nome
+arch.info.pkgrel=pubblicazione
+arch.info.pkgver=versione
+arch.info.provides=fornisce
+arch.info.replaces=sostituisce
+arch.info.required by=richiesto dalla
+arch.info.source=fonte
+arch.info.url=url
+arch.info.validated by=convalidato da
+arch.info.validated by.signature=firma
+arch.info.validpgpkeys=chiavi PGP valide
+arch.info.version=versione
+arch.install.aur.root_error.body=Non è consentito installare, aggiornare o degradare un pacchetto come utente root
+arch.install.aur.root_error.title=Azione non consentita
+arch.install.aur.unknown_key.body=Per continuare {} l'installazione è necessaria per fidarsi della seguente chiave pubblica {}
+arch.install.conflict.popup.body=Le applicazioni {} sono in conflitto. È necessario disinstallarne una per installare l'altra. Continua ?
+arch.install.conflict.popup.title=Conflitto rilevato
+arch.install.dep_not_found.body.l1=La dipendenza richiesta {} non è stata trovata in AUR né nei depositos.
+arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
+arch.install.dep_not_found.body.l3=Installazione annullata.
+arch.install.dep_not_found.title=Dipendenza non trovata
+arch.install.dependency.install=Installazione della dipendenza pacchetto {}
+arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
+arch.install.optdep.error=Could not install the optional packages: {}
+arch.install.optdeps.request.body={} è stato installato con successo! Ci sono alcuni pacchetti associati opzionali che potresti voler installare
+arch.install.optdeps.request.help=Controlla quelli che vuoi
+arch.install.optdeps.request.title=Dipendenze opzionali
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=Installazione del pacchetto {}
+arch.makepkg.optimizing=Ottimizzando la compilazione
+arch.missing_deps.body=Le seguenti {deps} dipendenze devono essere installate prima che l'installazione di {name} continui
+arch.missing_deps.title=Dipendenze mancanti
+arch.missing_deps_found=Dipendenze mancanti per {}
+arch.optdeps.checking=Verifica di {} dipendenze opzionali
+arch.providers=providers
+arch.substatus.checking keyring=Checking keyring
+arch.substatus.checking package integrity=Checking packages integrity
+arch.substatus.loading package files=Loading package files
+arch.substatus.checking for file conflicts=Checking for conflicts
+arch.substatus.checking available disk space=Checking available disk space
+arch.sync_databases.substatus=Synchronizing package databases
+arch.sync_databases.substatus.error=It was not possible to synchronize the package database
+arch.task.disk_cache=Organizzando i dati dai pacchetti installati
+arch.task.disk_cache.indexed=Pronti
+arch.task.disk_cache.prepared=Letti
+arch.task.disk_cache.reading=Determinando i pacchetti installati
+arch.task.mirrors=Aggiornando i mirror
+arch.task.optimizing=Ottimizzando {}
+arch.task.sync_databases.waiting=In attesa dell'aggiornamento dei mirror
+arch.task.sync_sb.status=Aggiornando {}
+arch.uncompressing.package=Non comprimere il pacchetto
+arch.uninstall.clean_cached.error=Non è stato possibile rimuovere le vecchie {} versioni trovate sul disco
+arch.uninstall.clean_cached.substatus=Rimozione di versioni precedenti dal disco
+arch.uninstall.required_by={} non può essere disinstallato perché è necessario che i seguenti pacchetti funzionino.
+arch.uninstall.required_by.advice=It is necessary to uninstall them as well to proceed.
+arch.uninstalling.conflict=Disinstallazione del pacchetto in conflitto {}
+arch.uninstalling.conflict.fail=Non è stato possibile disinstallare il pacchetto in conflitto {}
+arch.update.disabled.tooltip=This package can oly be upgrade through the action "Quick system upgrade"
+arch.update_summary.conflict_between=Conflict between {} and {}
+arch.update_summary.to_install.dep_conflict=Conflict between the dependencies {} and {}
+arch.update_summary.to_update.conflicts_dep=Conflicts with the dependency {} of {}
+arch.update_summary.to_update.dep_conflicts=Dependency {} conflicts with {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
+arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
+arch.warning.disabled={} sembra non essere installato. Non sarà possibile gestire i pacchetti Arch/AUR.
+arch.warning.git={} sembra non essere installato. Non sarà possibile effettuare il downgrade dei pacchetti AUR.
+arch_repo.history.1_version=versione
+arch_repo.history.2_release=rilascio
+arch_repo.history.3_date=data
 aur.history.1_version=versione
 aur.history.2_release=rilascio
 aur.history.3_date=data
-arch.downloading.package=Download del pacchetto
-arch.uncompressing.package=Non comprimere il pacchetto
-arch.checking.deps=Verifica di {} dipendenze
-arch.checking.missing_deps=Verifica delle dipendenze mancanti di {}
-arch.missing_deps_found=Dipendenze mancanti per {}
-arch.building.package=Pacchetto costruito {}
-arch.checking.conflicts=Verifica di eventuali conflitti con {}
-arch.installing.package=Installazione del pacchetto {}
-arch.uninstalling.conflict=Disinstallazione del pacchetto in conflitto {}
-arch.uninstalling.conflict.fail=Non è stato possibile disinstallare il pacchetto in conflitto {}
-arch.clone=Clonazione del repository AUR {}
-arch.downgrade.reading_commits=Reading the repository commits
-arch.downgrade.version_found=Trovata la versione del pacchetto corrente
-arch.downgrade.install_older=Installazione della versione precedente
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=nome
-aur.info.03_version=versione
-aur.info.03_description=descrizione
-aur.info.04_popularity=popularità
-aur.info.05_votes=voti
-aur.info.06_package_base=pacchetto base
-aur.info.07_maintainer=maintainer
-aur.info.08_first_submitted=first submitted
-aur.info.09_last_modified=ultima modifica
-aur.info.10_url=url di download
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=dipendenze di compilazione
-aur.info.13_dependson=dipendenze di installazione
-aur.info.14_optdepends=dipendenze opzionali
-aur.info.15_checkdepends=dipendenze di verifica
-aur.info.14_installed_files=File installati
-arch.install.dep_not_found.title=Dipendenza non trovata
-arch.install.dep_not_found.body=La dipendenza richiesta {} non è stata trovata in AUR né nei mirror predefiniti. Installazione annullata.
-arch.install.dependency.install=Installazione della dipendenza pacchetto {}
-arch.install.dependency.install.error=Impossibile installare il pacchetto dipendente {}. Installazione di {} interrotta.
-arch.uninstall.required_by={} non può essere disinstallato perché è necessario che i seguenti pacchetti funzionino
-arch.uninstall.required_by.advice= Uninstall them first before uninstalling {}.
-arch.install.optdeps.request.title=Dipendenze opzionali
-arch.install.optdeps.request.body={} è stato installato con successo! Ci sono alcuni pacchetti associati opzionali che potresti voler installare
-arch.install.optdeps.request.help=Controlla quelli che vuoi
-arch.install.optdep.error=Impossibile installare il pacchetto opzionale {}
-arch.optdeps.checking=Verifica di {} dipendenze opzionali
-arch.warning.disabled={} sembra non essere installato. Non sarà possibile gestire i pacchetti Arch/AUR.
-arch.warning.git={} sembra non essere installato. Non sarà possibile effettuare il downgrade dei pacchetti AUR.
-arch.aur.install.verifying_pgp=Verifica chiavi PGP
-arch.aur.install.pgp.title=Chiavi PGP richieste
-arch.aur.install.pgp.body=Per installare {} è necessario ricevere le seguenti chiavi PGP
-arch.aur.install.pgp.substatus=Ricezione della chiave PGP {}
-arch.aur.install.pgp.success=Chiavi PGP ricevute e firmate
-arch.aur.install.pgp.sign_fail=Impossibile firmare la chiave PGP {}
-arch.aur.install.pgp.receive_fail=Impossibile ricevere la chiave PGP {}
-arch.aur.install.unknown_key.title=Chiave pubblica richiesta
-arch.install.aur.unknown_key.body=Per continuare {} l'installazione è necessaria per fidarsi della seguente chiave pubblica {}
-arch.aur.install.unknown_key.status=Ricezione della chiave pubblica {}
-arch.aur.install.unknown_key.receive_error=Impossibile ricevere la chiave pubblica {}
-arch.aur.install.validity_check.title=Problemi di integrità {}
-arch.aur.install.validity_check.body=Alcuni dei file di origine necessari per l'installazione di {} non sono integri.
-arch.aur.install.validity_check.proceed=Vuoi continuare comunque? ( non consigliato )
-arch.makepkg.optimizing=Ottimizzando la compilazione
-arch.config.optimize=optimize
-arch.config.optimize.tip=Optimized settings will be used in order to make the packages installation faster, otherwise the system settings will be used
-arch.config.trans_dep_check=Previous dependencies checking
-arch.config.trans_dep_check.tip=If all package dependencies should be verified before installation begins, otherwise they will be discovered during installation.
-arch.sync_databases.substatus=Synchronizing package databases
-arch.sync_databases.substatus.error=It was not possible to synchronize the package database
-arch.config.sync_dbs=Synchronize packages databases
-arch.config.sync_dbs.tip=Synchronizes the package databases once a day ( or after a device reboot ) before the first package installation, upgrade or downgrade. This option help to prevent errors during these operations.
-arch.config.simple_dep_check=Verifica delle dipendenze semplice
-arch.config.simple_dep_check.tip=Se è necessario utilizzare solo la verifica della dipendenza fornita da pacman prima di installare un pacchetto (più veloce, ma non sempre accurato). Se disabilitato, verrà eseguito un controllo più completo (più lento, ma più accurato)
-arch.install.aur.root_error.title=Azione non consentita
-arch.install.aur.root_error.body=Non è consentito installare, aggiornare o degradare un pacchetto come utente root
+gem.arch.info=Software packages available for distributions based on Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Deposito
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=I pacchetti AUR sono gestiti da una comunità di utenti indipendenti. Non esiste alcuna garanzia che funzionino o non danneggino il sistema.

bauh/gems/arch/resources/locale/pt

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=Pacotes do AUR são mantidos por uma comunidade de usuários independente. Não há garantia que funcionarão ou que não prejudicarão o seus sistema.
-gem.aur.install.warning=Pacotes do AUR são mantidos por uma comunidade de usuários independente. Não há garantia que funcionarão ou que não prejudicarão o seus sistema.
-aur.info.architecture=arquitetura
-aur.info.architecture.any=qualquer
-aur.info.build date=data de construção
-aur.info.depends on=depende
-aur.info.description=descrição
-aur.info.install date=data de instalação
-aur.info.install reason=razão da instalação
-aur.info.install reason.explicitly installed=instalado explicitamente
-aur.info.install script=script de instalação
-aur.info.install script.no=nenhum
-aur.info.installed size=tamanho da instalação
-aur.info.licenses=licenças
-aur.info.name=nome
-aur.info.optional deps=dependências opcionais
-aur.info.packager=empacotador
-aur.info.packager.unknown packager=desconhecido
-aur.info.url=url
-aur.info.version=versão
-aur.info.arch=arquitetura
-aur.info.arch.any=qualquer
-aur.info.depends=depende
-aur.info.pkgdesc=descrição
-aur.info.pkgname=nome
-aur.info.pkgrel=lançamento
-aur.info.pkgver=versão
-aur.info.source=origem
-aur.info.optdepends=dependências opcionais
-aur.info.license=licença
-aur.info.validpgpkeys=chaves PGP válidas
-aur.info.options=opções
-aur.info.provides=provê
-aur.info.conflicts with=conflita
-arch.install.conflict.popup.title=Conflito detectado
-arch.install.conflict.popup.body=Os aplicativos {} estão em conflito. Você precisa desinstalar um para instalar o outro. Continuar ?
-arch.missing_deps.title=Dependências ausentes
-arch.missing_deps.body=As seguintes {deps} dependências devem ser instaladas para que a instalação de {name} continue
+arch.action.db_locked.body.l1=O banco de dados de pacotes do sistema está bloqueado.
+arch.action.db_locked.body.l2=É necessário desbloquea-lo para continuar.
+arch.action.db_locked.confirmation=Desbloquear e continuar
+arch.action.db_locked.error=Não foi possível desbloquear o banco de dados.
+arch.action.db_locked.title=Banco de dados bloqueado
+arch.aur.install.pgp.body=Para instalar {} é necessário receber as seguintes chaves PGP
+arch.aur.install.pgp.receive_fail=Não foi possível receber a chave PGP {}
+arch.aur.install.pgp.sign_fail=Não foi possível assinar a chave PGP {}
+arch.aur.install.pgp.substatus=Recebendo chave PGP {}
+arch.aur.install.pgp.success=Chaves PGP recebidas e assinadas
+arch.aur.install.pgp.title=Chaves PGP necessárias
+arch.aur.install.unknown_key.receive_error=Não fui possível receber a chave pública {}
+arch.aur.install.unknown_key.status=Recebendo a chave pública {}
+arch.aur.install.unknown_key.title=Chave pública necessária
+arch.aur.install.validity_check.body=Alguns dos arquivos-fonte necessários para a instalação de {} não estão íntegros.
+arch.aur.install.validity_check.proceed=Você deseja continuar mesmo assim ? ( não recomendado )
+arch.aur.install.validity_check.title=Problemas de integridade {}
+arch.aur.install.verifying_pgp=Verificando chaves PGP
+arch.building.package=Construindo o pacote {}
+arch.checking.conflicts=Verificando se há conflitos com {}
+arch.checking.deps=Verificando as dependências de {}
+arch.checking.missing_deps=Verificando dependências ausentes de {}
+arch.clone=Clonando o repositório {} do AUR
+arch.config.aur=Pacotes do AUR
+arch.config.aur.tip=Permite gerenciar pacotes dos AUR
+arch.config.clean_cache=Remover versões antigas
+arch.config.clean_cache.tip=Se versões antigas de um pacote armazenadas em disco devem ser removidas durante a desinstalação
+arch.config.mirrors_sort_limit=Limite de ordenação de espelhos
+arch.config.mirrors_sort_limit.tip=Define o número máximo de espelhos que serão utilizados para a ordenação por velocidade. Use 0 para não limitar ou deixe em branco para desabilitar a ordenação.
+arch.config.optimize=Otimizar
+arch.config.optimize.tip=Utilizará configurações otimizadas para que a instalação, atualização e reversão de pacotes sejam mais rápida, caso contrário utilizará a do sistema
+arch.config.refresh_mirrors=Atualizar espelhos ao iniciar
+arch.config.refresh_mirrors.tip=Atualiza os espelhos de pacotes uma vez ao dia na inicialização
+arch.config.repos=Pacotes de repositórios
+arch.config.repos.tip=Permite gerenciar pacotes dos repositórisos
+arch.config.sync_dbs=Sincronizar bases de pacotes
+arch.config.sync_dbs.tip=Sincroniza as bases de pacotes uma vez ao dia antes da primeira instalação, atualização ou reversão de pacote. Essa opção ajuda a evitar erros durante essa operações.
+arch.config.sync_dbs_start.tip=Sincroniza as bases de pacotes durante a inicialização uma vez ao dia
+arch.custom_action.clean_cache=Limpar cache
+arch.custom_action.clean_cache.fail=Ocorreu um problema durante a limpeza do cache
+arch.custom_action.clean_cache.msg1=Cache é um diretório no sistema onde ficam armazenados arquivos de versões antigas de alguns pacotes
+arch.custom_action.clean_cache.msg2=Limpá-lo aumenta o espaço de armazenamento disponível sem prejudicar o seu sistema
+arch.custom_action.clean_cache.msg3=Também auxilia quando há pacotes baixados com problemas de integridade que estão impossibilitando uma ação
+arch.custom_action.clean_cache.no_dir=O diretório de cache {} não existe
+arch.custom_action.clean_cache.status=Limpando cache
+arch.custom_action.clean_cache.success=Cache foi limpo com sucesso !
+arch.custom_action.refresh_dbs=Sincronizar bases de pacotes
+arch.custom_action.refresh_dbs.failed=Não foi possível sincronizar as bases de pacotes
+arch.custom_action.refresh_mirrors=Atualizar espelhos
+arch.custom_action.refresh_mirrors.failed=Não foi possível atualizar os espelhos
+arch.custom_action.refresh_mirrors.location.all=Todas
+arch.custom_action.refresh_mirrors.location.all.tip=Se essa opção estiver marcada, as demais serão ignoradas.
+arch.custom_action.refresh_mirrors.select_label=Marque as localizações desejadas
+arch.custom_action.refresh_mirrors.status.sorting=Ordenando os espelhos por velocidade
+arch.custom_action.refresh_mirrors.status.updating=Atualizando espelhos
+arch.custom_action.upgrade_system=Atualização rápida de sistema
+arch.custom_action.upgrade_system.no_updates=Não há atualizações disponíveis
+arch.custom_action.upgrade_system.pkgs=Os pacotes abaixo serão atualizados
+arch.custom_action.upgrade_system.status=Atualizando sistema
+arch.custom_action.upgrade_system.substatus=Atualizando pacotes
+arch.custom_action.upgrade_system.success.line1=Sistema atualizado com sucesso !
+arch.custom_action.upgrade_system.success.line2=Algumas mudanças podem exigir a reinicialização do sistem para que surtam efeito.
+arch.custom_action.upgrade_system.success.line3=Reiniciar agora ?
+arch.dialog.providers.line1=Existem multiplos provedores para algumas das dependências
+arch.dialog.providers.line2=Selecione os desejados
 arch.downgrade.error=Erro
 arch.downgrade.impossible=Não é possível reverter a versão de {}
+arch.downgrade.install_older=Instalando versão anterior
+arch.downgrade.reading_commits=Lendo os commits do repositório
+arch.downgrade.repo_pkg.no_versions=Nenhuma versão antiga encontrada no disco
+arch.downgrade.searching_stored=Procurando versões antigas no disco
+arch.downgrade.version_found=Versão atual do pacote encontrada
+arch.downloading.package=Baixando o pacote
+arch.info.00_pkg_build=pkgbuild
+arch.info.01_id=id
+arch.info.02_name=nome
+arch.info.03_description=descrição
+arch.info.03_version=versão
+arch.info.04_popularity=popularidade
+arch.info.05_votes=votos
+arch.info.06_package_base=pacote base
+arch.info.07_maintainer=mantenedor
+arch.info.08_first_submitted=primeira submissão
+arch.info.09_last_modified=última modificação
+arch.info.10_url=url para baixar
+arch.info.11_pkg_build_url=url pkgbuild
+arch.info.12_makedepends=dependências de compilação
+arch.info.13_dependson=dependências de instalação
+arch.info.13_pkg_build=pkgbuild
+arch.info.14_installed_files=arquivos instalados
+arch.info.14_optdepends=dependências opcionais
+arch.info.15_checkdepends=dependências de verificação
+arch.info.arch=arquitetura
+arch.info.arch.any=qualquer
+arch.info.architecture=arquitetura
+arch.info.architecture.any=qualquer
+arch.info.build date=data de construção
+arch.info.conflicts with=conflita com
+arch.info.depends=depende
+arch.info.depends on=depende de
+arch.info.description=descrição
+arch.info.download size=Tamanho do arquivo (download)
+arch.info.install date=data de instalação
+arch.info.install reason=razão da instalação
+arch.info.install reason.explicitly installed=instalado explicitamente
+arch.info.install reason.installed as a dependency for another package=dependência de outro pacote
+arch.info.install script=script de instalação
+arch.info.install script.no=nenhum
+arch.info.installed files=arquivos instalados
+arch.info.installed size=tamanho da instalação
+arch.info.license=licença
+arch.info.licenses=licenças
+arch.info.licenses.custom=personalizada
+arch.info.name=nome
+arch.info.optdepends=dependências opcionais
+arch.info.optional deps=dependências opcionais
+arch.info.optional for=opcional para
+arch.info.options=opções
+arch.info.packager=empacotador
+arch.info.packager.unknown packager=desconhecido
+arch.info.pkgdesc=descrição
+arch.info.pkgname=nome
+arch.info.pkgrel=lançamento
+arch.info.pkgver=versão
+arch.info.provides=provê
+arch.info.replaces=substitui
+arch.info.required by=requerido por
+arch.info.source=origem
+arch.info.url=url
+arch.info.validated by=validador por
+arch.info.validated by.signature=assinatura
+arch.info.validpgpkeys=Chaves PGP válidas
+arch.info.version=versão
+arch.install.aur.root_error.body=Não é permitido instalar, atualizar ou reverter a versão de um pacote como usuário root
+arch.install.aur.root_error.title=Ação não permitida
+arch.install.aur.unknown_key.body=Para continuar a instalação de {} é ncessário confiar na seguinte chave pública {}
+arch.install.conflict.popup.body=Os aplicativos {} estão em conflito. Você precisa desinstalar um para instalar o outro. Continuar ?
+arch.install.conflict.popup.title=Conflito detectado
+arch.install.dep_not_found.body.l1=A dependência {} não foi encontrado no AUR nem nos repositórios.
+arch.install.dep_not_found.body.l2=Pode ser um problema de sincronização das bases de pacotes.
+arch.install.dep_not_found.body.l3=Instalação cancelada.
+arch.install.dep_not_found.title=Dependência não encontrada
+arch.install.dependency.install=Instalando o pacote dependente {}
+arch.install.dependency.install.error=Não foi possível instalar os pacotes dependentes: {}. Instalação de {} abortada.
+arch.install.optdep.error=Não foi possível instalar os pacotes opcionais: {}
+arch.install.optdeps.request.body={} foi instalado com sucesso ! Existem alguns pacotes opcionais associados que você talvez queira instalar
+arch.install.optdeps.request.help=Marque os desejados
+arch.install.optdeps.request.title=Dependências opcionais
+arch.install.repo_pkg.error.aur_deps=Não é possível instalar um pacote do AUR como dependência de um pacote de repositório
+arch.installing.package=Instalando o pacote {}
+arch.makepkg.optimizing=Otimizando a compilação
+arch.missing_deps.body=As seguintes {deps} dependências devem ser instaladas para que a instalação de {name} continue
+arch.missing_deps.title=Dependências ausentes
+arch.missing_deps_found=Dependencias ausentes para {}
+arch.optdeps.checking=Verificando as dependências opcionais de {}
+arch.providers=provedores
+arch.substatus.checking keyring=Verificando o keyring
+arch.substatus.checking package integrity=Verificando a integridade dos pacotes
+arch.substatus.loading package files=Carregando os arquivos dos pacotes
+arch.substatus.checking for file conflicts=Verificando conflitos
+arch.substatus.checking available disk space=Verificando espaço disponível em disco
+arch.sync_databases.substatus=Sincronizando bases de pacotes
+arch.sync_databases.substatus.error=Não foi possível sincronizar as bases de pacotes
+arch.task.disk_cache=Organizando dados dos pacotes instalados
+arch.task.disk_cache.indexed=Prontos
+arch.task.disk_cache.prepared=Lidos
+arch.task.disk_cache.reading=Determinando pacotes instalados
+arch.task.mirrors=Atualizando espelhos
+arch.task.optimizing=Otimizando {}
+arch.task.sync_databases.waiting=Aguardando atualização de espelhos
+arch.task.sync_sb.status=Atualizando {}
+arch.uncompressing.package=Descompactando o pacote
+arch.uninstall.clean_cached.error=Não foi possível remover versões antigas de {} encontradas em disco
+arch.uninstall.clean_cached.substatus=Removendo versões antigas do disco
+arch.uninstall.required_by={} não pode ser desinstalado porque ele é necessário para o funcionamento dos pacotes listados abaixo.
+arch.uninstall.required_by.advice=Para prosseguir será necessário desinstá-los também.
+arch.uninstalling.conflict=Desinstalando o pacote conflitante {}
+arch.uninstalling.conflict.fail=Não foi possível desinstalar o pacote conflitante {}
+arch.update.disabled.tooltip=Este pacote só pode ser atualizado através da ação "Atualização rápida de sistema"
+arch.update_summary.conflict_between=Conflito entre {} e {}
+arch.update_summary.to_install.dep_conflict=Conflito entre as dependências {} e {}
+arch.update_summary.to_update.conflicts_dep=Conflita com a dependência {} de {}
+arch.update_summary.to_update.dep_conflicts=A dependência {} conflita com {}
+arch.upgrade.caching_pkgs_data=Armazenando dados das atualizações
+arch.upgrade.upgrade_aur_pkgs=Atualizando pacotes do AUR
+arch.upgrade.upgrade_repo_pkgs=Atualizando pacotes dos repositórios
+arch.warning.disabled={} parece não estar instalado. Não será possível gerenciar pacotes Arch / AUR.
+arch.warning.git={} parece não estar instalado. Não será possível reverter versões de pacotes Arch / AUR.
+arch_repo.history.1_version=versão
+arch_repo.history.2_release=lançamento
+arch_repo.history.3_date=data
 aur.history.1_version=versão
 aur.history.2_release=lançamento
 aur.history.3_date=data
-arch.downloading.package=Baixando o pacote
-arch.uncompressing.package=Descompactando o pacote
-arch.checking.deps=Verificando as dependências de {}
-arch.checking.missing_deps=Verificando dependências ausentes de {}
-arch.missing_deps_found=Dependencias ausentes para {}
-arch.building.package=Construindo o pacote {}
-arch.checking.conflicts=Verificando se há conflitos com {}
-arch.installing.package=Instalando o pacote {}
-arch.uninstalling.conflict=Desinstalando o pacote conflitante {}
-arch.uninstalling.conflict.fail=Não foi possível desinstalar o pacote conflitante {}
-arch.clone=Clonando o repositório {} do AUR
-arch.downgrade.reading_commits=Lendo os commits do repositório
-arch.downgrade.version_found=Versão atual do pacote encontrada
-arch.downgrade.install_older=Instalando versão anterior
-aur.info.00_pkg_build=pkgbuild
-aur.info.01_id=id
-aur.info.02_name=nome
-aur.info.03_version=versão
-aur.info.03_description=descrição
-aur.info.04_popularity=popularidade
-aur.info.05_votes=votos
-aur.info.06_package_base=pacote base
-aur.info.07_maintainer=mantenedor
-aur.info.08_first_submitted=primeira submissão
-aur.info.09_last_modified=última modificação
-aur.info.10_url=url download
-aur.info.11_pkg_build_url=url pkgbuild
-aur.info.13_pkg_build=pkgbuild
-aur.info.12_makedepends=dependências para compilação
-aur.info.13_dependson=dependências para instalação
-aur.info.14_optdepends=dependências opcionais
-aur.info.15_checkdepends=dependências para verificação
-aur.info.14_installed_files=Arquivos instalados
-arch.install.dep_not_found.title=Dependência não encontrada
-arch.install.dep_not_found.body=A dependência {} não foi encontrado no AUR nem nos espelhos padrões. Instalação cancelada.
-arch.install.dependency.install=Instalando o pacote dependente {}
-arch.install.dependency.install.error=Não foi possível instalar o pacote dependente {}. Instalação de {} abortada.
-arch.uninstall.required_by={} não pode ser desinstalado porque ele é necessário para o funcionamento dos seguintes pacotes
-arch.uninstall.required_by.advice=Desinstale eles primeiro antes de desinstalar {}
-arch.install.optdeps.request.title=Dependências opcionais
-arch.install.optdeps.request.body={} foi instalado com sucesso ! Existem alguns pacotes opcionais associados que você talvez queira instalar
-arch.install.optdeps.request.help=Marque os desejados
-arch.install.optdep.error=Não foi possível instalar o pacote opcional {}
-arch.optdeps.checking=Verificando as dependências opcionais de {}
-arch.warning.disabled={} parece não estar instalado. Não será possível gerenciar pacotes Arch / AUR.
-arch.warning.git={} parece não estar instalado. Não será possível reverter versões de pacotes Arch / AUR.
-arch.aur.install.verifying_pgp=Verificando chaves PGP
-arch.aur.install.pgp.title=Chaves PGP necessárias
-arch.aur.install.pgp.body=Para instalar {} é necessário receber as seguintes chaves PGP
-arch.aur.install.pgp.substatus=Recebendo chave PGP {}
-arch.aur.install.pgp.success=Chaves PGP recebidas e assinadas
-arch.aur.install.pgp.sign_fail=Não foi possível assinar a chave PGP {}
-arch.aur.install.pgp.receive_fail=Não foi possível receber a chave PGP {}
-arch.aur.install.unknown_key.title=Chave pública necessária
-arch.install.aur.unknown_key.body=Para continuar a instalação de {} é ncessário confiar na seguinte chave pública {}
-arch.aur.install.unknown_key.status=Recebendo a chave pública {}
-arch.aur.install.unknown_key.receive_error=Não fui possível receber a chave pública {}
-arch.aur.install.validity_check.title=Problemas de integridade {}
-arch.aur.install.validity_check.body=Alguns dos arquivos-fonte necessários para a instalação de {} não estão íntegros.
-arch.aur.install.validity_check.proceed=Você deseja continuar mesmo assim ? ( não recomendado )
-arch.makepkg.optimizing=Otimizando a compilação
-arch.config.optimize=Otimizar
-arch.config.optimize.tip=Utilizará configurações otimizadas para que a instalação de pacotes seja mais rápida, caso contrário utilizará a do sistema
-arch.config.trans_dep_check=Verificação prévia de dependências
-arch.config.trans_dep_check.tip=Se todas as dependências do pacote devem ser verificadas antes da instalação começar, caso contrário elas serão descobertas durante a instalação.
-arch.sync_databases.substatus=Sincronizando bases de pacotes
-arch.sync_databases.substatus.error=Não foi possível sincronizar as bases de pacotes
-arch.config.sync_dbs=Sincronizar bases de pacotes
-arch.config.sync_dbs.tip=Sincroniza as bases de pacotes uma vez ao dia ( ou a cada reinicialização do dispositivo ) antes da primeira instalação, atualização ou reversão de um pacote. Essa opção ajuda a evitar erros durante essa operações.
-arch.config.simple_dep_check=Verificação de dependências simples
-arch.config.simple_dep_check.tip=Se somente a verificação de dependências provida pelo pacman deve ser usada antes de instalar um pacote ( mais rápida, porém nem sempre precisa ). Se desativada, uma verificação mais completa será realizada ( mais lenta, porém mais precisa )
-arch.install.aur.root_error.title=Ação não permitida
-arch.install.aur.root_error.body=Não é permitido instalar, atualizar ou reverter a versão de um pacote como usuário root
+gem.arch.info=Pacotes de software disponíveis para distribuições baseadas em Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Repositório
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=Pacotes do AUR são mantidos por uma comunidade de usuários independente. Não há garantia que funcionarão ou que não prejudicarão o seus sistema.

bauh/gems/arch/resources/locale/ru

@@ -1,117 +1,199 @@
-gem.arch.label=AUR
-gem.arch.info=AUR-пакеты поддерживаются независимым сообществом пользователей. Нет никакой гарантии, что они будут работать или не навредят вашей системе.
-gem.aur.install.warning=AUR-пакеты поддерживаются независимым сообществом пользователей. Нет никакой гарантии, что они будут работать или не навредят вашей системе.
-arch.install.conflict.popup.title=Обнаружен конфликт
-arch.install.conflict.popup.body=Приложения {} находятся в конфликте. Вы должны удалить одно, чтобы установить другоое. Продолжить ?
-arch.missing_deps.title=Отсутствующие зависимости
-arch.missing_deps.body=Необходимо установить следующие зависимости , чтобы продолжить установку {name} 
+arch.action.db_locked.body.l1=The system package database is locked.
+arch.action.db_locked.body.l2=It is necessary to unlock it to continue.
+arch.action.db_locked.confirmation=Unlock and continue
+arch.action.db_locked.error=It was not possible to unlock the database.
+arch.action.db_locked.title=Database locked
+arch.aur.install.pgp.body=Для установки {} необходимо получить следующие PGP ключи
+arch.aur.install.pgp.receive_fail=Не удалось получить PGP-ключ {}
+arch.aur.install.pgp.sign_fail=Не удалось подписать PGP-ключ {}
+arch.aur.install.pgp.substatus=Получение PGP-ключа {}
+arch.aur.install.pgp.success=Ключи PGP получены и подписаны
+arch.aur.install.pgp.title=Требуются ключи PGP
+arch.aur.install.unknown_key.receive_error=Не удалось получить открытый ключ {}
+arch.aur.install.unknown_key.status=Получение открытого ключа {}
+arch.aur.install.unknown_key.title=Требуется открытый ключ
+arch.aur.install.validity_check.body=Некоторые исходные файлы, необходимые для установки {}, не работают. Установка будет отменена, чтобы предотвратить повреждение вашей системы.
+arch.aur.install.validity_check.proceed=Вы всё равно хотите продолжить ? ( не рекомендуется )
+arch.aur.install.validity_check.title=Проблемы целостности
+arch.aur.install.verifying_pgp=Проверка ключей PGP
+arch.building.package=Сборка пакета {}
+arch.checking.conflicts=Проверка конфликтов с {}
+arch.checking.deps=Проверка зависимостей {}
+arch.checking.missing_deps=Проверка отсутствующих зависимостей {}
+arch.clone=Клонирование AUR-репозитория {}
+arch.config.aur=пакеты AUR
+arch.config.aur.tip=Это позволяет управлять пакетами AUR
+arch.config.clean_cache=Remove old versions
+arch.config.clean_cache.tip=Whether old versions of a package stored on disk should be removed during uninstall
+arch.config.mirrors_sort_limit=Ограничение сортировки зеркал
+arch.config.mirrors_sort_limit.tip=Определяет максимальное количество зеркал, которые будут использоваться для сортировки по скорости. Используйте 0 для No limit или оставьте его пустым, чтобы отключить сортировку.
+arch.config.optimize=Оптимизация
+arch.config.optimize.tip=Оптимизированные настройки будут использоваться для ускорения установки пакетов, в противном случае будут использоваться системные настройки
+arch.config.refresh_mirrors=Обновить зеркала при запуске
+arch.config.refresh_mirrors.tip=Обновляйте зеркала пакета один раз в день при запуске (или после перезагрузки устройства)
+arch.config.repos=Пакеты репозиториев
+arch.config.repos.tip=Он позволяет управлять пакетами из набора репозиториев
+arch.config.sync_dbs=Синхронизация баз данных пакетов
+arch.config.sync_dbs.tip=Синхронизируйте базы данных пакетов один раз в день перед первой установкой, обновлением или понижением версии пакета. Этот параметр помогает предотвратить ошибки во время этих операций.
+arch.config.sync_dbs_start.tip=Синхронизирует базы данных пакетов во время инициализации один раз в день
+arch.custom_action.clean_cache=Clean cache
+arch.custom_action.clean_cache.fail=An error occurred while cleaning the cache
+arch.custom_action.clean_cache.msg1=The cache is a system directory where files of old package versions are stored
+arch.custom_action.clean_cache.msg2=Cleaning it frees storage space without harming your system
+arch.custom_action.clean_cache.msg3=It also helps when there are downloaded packages with integrity issues blocking an action
+arch.custom_action.clean_cache.no_dir=The cache directory {} does not exist
+arch.custom_action.clean_cache.status=Cleaning cache
+arch.custom_action.clean_cache.success=Cache successfully cleaned !
+arch.custom_action.refresh_dbs=Синхронизация баз данных пакетов
+arch.custom_action.refresh_dbs.failed=Синхронизировать базу данных пакета не удалось
+arch.custom_action.refresh_mirrors=Обновить список зеркал
+arch.custom_action.refresh_mirrors.failed=Обновить зеркала не удалось
+arch.custom_action.refresh_mirrors.location.all=Все
+arch.custom_action.refresh_mirrors.location.all.tip=Если этот параметр установлен, остальные будут проигнорированы.
+arch.custom_action.refresh_mirrors.select_label=Проверка предпочитаемых расположений
+arch.custom_action.refresh_mirrors.status.sorting=Sorting mirrors by speed
+arch.custom_action.refresh_mirrors.status.updating=Сортировка зеркал по скорости
+arch.custom_action.upgrade_system=Обновление системы
+arch.custom_action.upgrade_system.no_updates=Обновления отсутствуют
+arch.custom_action.upgrade_system.pkgs=Следующие пакеты будут обновлены
+arch.custom_action.upgrade_system.status=Система обновлена
+arch.custom_action.upgrade_system.substatus=Обновление пакетов
+arch.custom_action.upgrade_system.success.line1=Система успешно обновлена!
+arch.custom_action.upgrade_system.success.line2=Для вступления в силу некоторых изменений может потребоваться перезагрузка системы.
+arch.custom_action.upgrade_system.success.line3=Перезагрузить сейчас ?
+arch.dialog.providers.line1=There are multiple providers for some dependencies
+arch.dialog.providers.line2=Select those you want
 arch.downgrade.error=Ошибка
 arch.downgrade.impossible=Невозможно понизить версию {}
+arch.downgrade.install_older=Установка старой версии
+arch.downgrade.reading_commits=Чтение коммитов репозитория
+arch.downgrade.repo_pkg.no_versions=No old version found on disk
+arch.downgrade.searching_stored=Looking for old versions on disk
+arch.downgrade.version_found=Найдена текущая версия пакета
+arch.downloading.package=Загрузка пакета
+arch.info.00_pkg_build=PKGBUILD
+arch.info.01_id=Идентификатор
+arch.info.02_name=Имя
+arch.info.03_description=Описание
+arch.info.03_version=Версия
+arch.info.04_popularity=Популярность
+arch.info.05_votes=Голоса
+arch.info.06_package_base=Базовый пакет
+arch.info.07_maintainer=Сопровождающий
+arch.info.08_first_submitted=Впервые представлен
+arch.info.09_last_modified=Последнее изменение
+arch.info.10_url=Страница загрузки
+arch.info.11_pkg_build_url=Страница PKGBUILD
+arch.info.12_makedepends=Зависимости компиляции
+arch.info.13_dependson=Зависимости установки
+arch.info.13_pkg_build=PKGBUILD
+arch.info.14_installed_files=Устанавливаемые файлы
+arch.info.14_optdepends=Необязательные зависимости
+arch.info.15_checkdepends=Проверка зависимостей
+arch.info.arch=Архитектура
+arch.info.arch.any=Несколько
+arch.info.architecture=Архитектура
+arch.info.architecture.any=Несколько
+arch.info.build date=Дата сборки
+arch.info.conflicts with=Конфликты с
+arch.info.depends=Зависимости
+arch.info.depends on=Зависит от
+arch.info.description=Описание
+arch.info.download size=Download size
+arch.info.install date=Дата установки
+arch.info.install reason=Причина установки
+arch.info.install reason.explicitly installed=установлен явно
+arch.info.install reason.installed as a dependency for another package=зависимость от другого пакета
+arch.info.install script=Скрипт установки
+arch.info.install script.no=Нет
+arch.info.installed files=установленные файлы
+arch.info.installed size=Размер установки
+arch.info.license=Лицензия
+arch.info.licenses=Лицензии
+arch.info.licenses.custom=таможенная
+arch.info.name=Имя
+arch.info.optdepends=Необязательные зависимости
+arch.info.optional deps=Необязательные зависимости
+arch.info.optional for=необязательно для
+arch.info.options=Опции
+arch.info.packager=Упаковщик
+arch.info.packager.unknown packager=Неизвестно
+arch.info.pkgdesc=Описание
+arch.info.pkgname=Имя
+arch.info.pkgrel=Релиз
+arch.info.pkgver=Версия
+arch.info.provides=Поставщик
+arch.info.replaces=Заменяет
+arch.info.required by=требуется
+arch.info.source=Источник
+arch.info.url=Страница
+arch.info.validated by=подтверждено
+arch.info.validated by.signature=подпись
+arch.info.validpgpkeys=Действительные PGP-ключи
+arch.info.version=Версия
+arch.install.aur.root_error.body=Не разрешается устанавливать, обновлять или понижать версию пакета от имени пользователя root
+arch.install.aur.root_error.title=Недопустимое действие
+arch.install.aur.unknown_key.body=Для продолжения установки {} необходимо довериться следующему открытому ключу {}
+arch.install.conflict.popup.body=Приложения {} находятся в конфликте. Вы должны удалить одно, чтобы установить другоое. Продолжить ?
+arch.install.conflict.popup.title=Обнаружен конфликт
+arch.install.dep_not_found.body.l1=Требуемая зависимость {} не была найдена ни в AUR, ни в зеркалах по умолчанию.
+arch.install.dep_not_found.body.l2=It might be a package database synchronization problem.
+arch.install.dep_not_found.body.l3=Установка отменена.
+arch.install.dep_not_found.title=Зависимость не найдена
+arch.install.dependency.install=Установка зависимостей пакета  {}
+arch.install.dependency.install.error=Could not install the dependent packages: {}. Installation of {} aborted.
+arch.install.optdep.error=Could not install the optional packages: {}
+arch.install.optdeps.request.body={} успешно установлен ! Есть некоторые дополнительные связанные пакеты, которые вы можете установить
+arch.install.optdeps.request.help=Отметьте те, которые вы хотите установить
+arch.install.optdeps.request.title=Необязательные зависимости
+arch.install.repo_pkg.error.aur_deps=It is not possible to install an AUR package as dependency of a repository package
+arch.installing.package=Установка пакета {}
+arch.makepkg.optimizing=Оптимизация компиляции
+arch.missing_deps.body=Необходимо установить следующие зависимости , чтобы продолжить установку {name}
+arch.missing_deps.title=Отсутствующие зависимости
+arch.missing_deps_found=Отсутствуют зависимости для {}
+arch.optdeps.checking=Проверка необязательных обязательных зависимостей {}
+arch.providers=providers
+arch.substatus.checking keyring=Checking keyring
+arch.substatus.checking package integrity=Checking packages integrity
+arch.substatus.loading package files=Loading package files
+arch.substatus.checking for file conflicts=Checking for conflicts
+arch.substatus.checking available disk space=Checking available disk space
+arch.sync_databases.substatus=Синхронизация баз данных пакетов
+arch.sync_databases.substatus.error=Синхронизировать базу данных пакета не удалось
+arch.task.disk_cache=Organizing data from installed packages
+arch.task.disk_cache.indexed=Ready
+arch.task.disk_cache.prepared=Read
+arch.task.disk_cache.reading=Determining installed packages
+arch.task.mirrors=Обновление зеркал
+arch.task.optimizing=Optimizing {}
+arch.task.sync_databases.waiting=Ожидание обновления зеркал
+arch.task.sync_sb.status=Updating {}
+arch.uncompressing.package=Распаковка пакета
+arch.uninstall.clean_cached.error=It was not possible to remove old {} versions found on disk
+arch.uninstall.clean_cached.substatus=Removing old versions from disk
+arch.uninstall.required_by={} не может быть удален, так как это необходимо для работы следующих пакетов
+arch.uninstall.required_by.advice=It is necessary to uninstall them as well to proceed.
+arch.uninstalling.conflict=Удаление конфликтующего пакета {}
+arch.uninstalling.conflict.fail=Не удалось удалить конфликтующий пакет {}
+arch.update.disabled.tooltip=Этот пакет может быть обновлен только через действие "обновить систему"
+arch.update_summary.conflict_between=Конфликт между {} и {}
+arch.update_summary.to_install.dep_conflict=Конфликт между зависимостями {} и {}
+arch.update_summary.to_update.conflicts_dep=Конфликты с зависимостью {} от {}
+arch.update_summary.to_update.dep_conflicts=Зависимость {} конфликтует с {}
+arch.upgrade.caching_pkgs_data=Caching upgrades data
+arch.upgrade.upgrade_aur_pkgs=Upgrading AUR packages
+arch.upgrade.upgrade_repo_pkgs=Upgrading packages from repositories
+arch.warning.disabled={} кажется, не установлен. Управлять пакетами Arch / AUR будет невозможно.
+arch.warning.git={} кажется, не установлен. Понижение версии пакетов AUR невозможно.
+arch_repo.history.1_version=version
+arch_repo.history.2_release=release
+arch_repo.history.3_date=date
 aur.history.1_version=Версия
 aur.history.2_release=Выпуск
 aur.history.3_date=Дата
-arch.downloading.package=Загрузка пакета
-arch.uncompressing.package=Распаковка пакета
-arch.checking.deps=Проверка зависимостей {}
-arch.missing_deps_found=Отсутствуют зависимости для {}
-arch.checking.missing_deps=Проверка отсутствующих зависимостей {}
-arch.building.package=Сборка пакета {}
-arch.checking.conflicts=Проверка конфликтов с {}
-arch.installing.package=Установка пакета {} 
-arch.uninstalling.conflict=Удаление конфликтующего пакета {}
-arch.uninstalling.conflict.fail=Не удалось удалить конфликтующий пакет {}
-arch.clone=Клонирование AUR-репозитория {}
-arch.downgrade.reading_commits=Чтение коммитов репозитория
-arch.downgrade.version_found=Найдена текущая версия пакета
-arch.downgrade.install_older=Установка старой версии
-aur.info.00_pkg_build=PKGBUILD
-aur.info.01_id=Идентификатор
-aur.info.02_name=Имя
-aur.info.03_version=Версия
-aur.info.03_description=Описание
-aur.info.04_popularity=Популярность
-aur.info.05_votes=Голосаолоса
-aur.info.06_package_base=Базовый пакет 
-aur.info.07_maintainer=Сопровождающий
-aur.info.08_first_submitted=Впервые представлен
-aur.info.09_last_modified=Последнее изменение
-aur.info.10_url=Страница загрузки
-aur.info.11_pkg_build_url=Страница PKGBUILD
-aur.info.13_pkg_build=PKGBUILD
-aur.info.12_makedepends=Зависимости компиляции
-aur.info.13_dependson=Зависимости установки
-aur.info.14_optdepends=Необязательные зависимости
-aur.info.15_checkdepends=Проверка зависимостей
-aur.info.14_installed_files=Устанавливаемые файлы
-arch.install.dep_not_found.title=Зависимость не найдена
-arch.install.dep_not_found.body=Требуемая зависимость {} не была найдена ни в AUR, ни в зеркалах по умолчанию. Установка отменена.
-arch.install.dependency.install=Установка зависимостей пакета  {}
-arch.install.dependency.install.error=Не удалось установить зависимый пакет {}. Установка {} прервана.
-arch.uninstall.required_by={} не может быть удален, так как это необходимо для работы следующих пакетов
-arch.uninstall.required_by.advice=Удалите их сначала перед удалением {}.
-arch.install.optdeps.request.title=Необязательные зависимости
-arch.install.optdeps.request.body={} успешно установлен ! Есть некоторые дополнительные связанные пакеты, которые вы можете установить
-arch.install.optdeps.request.help=Отметьте те, которые вы хотите установить
-arch.install.optdep.error=Не удалось установить дополнительный пакет {}
-arch.optdeps.checking=Проверка необязательных обязательных зависимостей {}
-arch.warning.disabled={} кажется, не установлен. Управлять пакетами Arch / AUR будет невозможно.
-arch.warning.git={} кажется, не установлен. Понижение версии пакетов AUR невозможно.
-arch.aur.install.verifying_pgp=Проверка ключей PGP
-arch.aur.install.pgp.title=Требуются ключи PGP
-arch.aur.install.pgp.body=Для установки {} необходимо получить следующие PGP ключи
-arch.aur.install.pgp.substatus=Получение PGP-ключа {}
-arch.aur.install.pgp.success=Ключи PGP получены и подписаны
-arch.aur.install.pgp.sign_fail=Не удалось подписать PGP-ключ {}
-arch.aur.install.pgp.receive_fail=Не удалось получить PGP-ключ {}
-arch.aur.install.unknown_key.title=Требуется открытый ключ
-arch.install.aur.unknown_key.body=Для продолжения установки {} необходимо довериться следующему открытому ключу {}
-arch.aur.install.unknown_key.status=Получение открытого ключа {}
-arch.aur.install.unknown_key.receive_error=Не удалось получить открытый ключ {}
-arch.aur.install.validity_check.title=Проблемы целостности
-arch.aur.install.validity_check.body=Некоторые исходные файлы, необходимые для установки {}, не работают. Установка будет отменена, чтобы предотвратить повреждение вашей системы.
-arch.aur.install.validity_check.proceed=Вы всё равно хотите продолжить ? ( не рекомендуется )																							
-aur.info.architecture=Архитектура
-aur.info.architecture.any=Несколько
-aur.info.build date=Дата сборки
-aur.info.depends on=Зависит от
-aur.info.description=Описание
-aur.info.install date=Дата установки
-aur.info.install reason=Причина установки
-aur.info.install reason.explicitly installed=Явно установлено
-aur.info.install script=Скрипт установки
-aur.info.install script.no=Нет
-aur.info.installed size=Размер установки
-aur.info.licenses=Лицензии
-aur.info.name=Имя
-aur.info.optional deps=Необязательные зависимости
-aur.info.packager=Упаковщик
-aur.info.packager.unknown packager=Неизвестно
-aur.info.url=Страница
-aur.info.version=Версия
-aur.info.arch=Архитектура
-aur.info.arch.any=Несколько
-aur.info.depends=Зависимости
-aur.info.pkgdesc=Описание
-aur.info.pkgname=Имя
-aur.info.pkgrel=Релиз
-aur.info.pkgver=Версия
-aur.info.source=Источник
-aur.info.optdepends=Необязательные зависимости
-aur.info.license=Лицензия
-aur.info.validpgpkeys=Действительные PGP-ключи
-aur.info.options=Опции
-aur.info.provides=Поставщик
-aur.info.conflicts with=Конфликты с
-arch.makepkg.optimizing=Оптимизация компиляции
-arch.config.optimize=Оптимизация
-arch.config.optimize.tip=Оптимизированные настройки будут использоваться для ускорения установки пакетов, в противном случае будут использоваться системные настройки
-arch.config.trans_dep_check=Предварительная проверка зависимостей
-arch.config.trans_dep_check.tip=Если все зависимости пакета должны быть проверены до начала установки. В противном случае они будут обнаружены во время установки.
-arch.sync_databases.substatus=Синхронизация баз данных пакетов
-arch.sync_databases.substatus.error=Синхронизировать базу данных пакета не удалось
-arch.config.sync_dbs=Синхронизация баз данных пакетов
-arch.config.sync_dbs.tip=Синхронизируйте базы данных пакетов один раз в день ( или после перезагрузки устройства ) перед первой установкой, обновлением или понижением версии пакета. Этот параметр помогает предотвратить ошибки во время этих операций.
-arch.config.simple_dep_check=Простая проверка зависимостей
-arch.config.simple_dep_check.tip=Если только проверка зависимостей, предоставляемая pacman, должна использоваться перед установкой пакета (быстрее, но не всегда точно ). Если этот параметр отключен, выполняется более полная проверка ( более медленная, но более точная )
-arch.install.aur.root_error.title=Недопустимое действие
-arch.install.aur.root_error.body=Не разрешается устанавливать, обновлять или понижать версию пакета от имени пользователя root													 
+gem.arch.info=Пакеты программного обеспечения, доступные для дистрибутивов на базе Arch Linux
+gem.arch.label=Arch
+gem.arch.type.arch_repo.label=Arch - Repository
+gem.arch.type.aur.label=Arch - AUR
+gem.aur.install.warning=AUR-пакеты поддерживаются независимым сообществом пользователей. Нет никакой гарантии, что они будут работать или не навредят вашей системе.

bauh/gems/arch/sorting.py

@@ -0,0 +1,148 @@
+from typing import Dict, Set, Iterable, Tuple, List
+
+
+def __add_dep_to_sort(pkgname: str, pkgs_data: Dict[str, dict], sorted_names: dict, not_sorted: Set[str],
+                      provided_map: Dict[str, str]):
+    idx = sorted_names.get(pkgname)
+
+    if idx is not None:
+        return idx
+    else:
+        idx = len(sorted_names)
+        sorted_names[pkgname] = idx
+
+        for dep in pkgs_data[pkgname]['d']:
+            dep_idx = sorted_names.get(dep)
+
+            if dep_idx is not None and dep_idx + 1 > idx:
+                idx = dep_idx + 1
+            else:
+                real_dep = provided_map.get(dep)  # gets the real package name instead of the provided one
+
+                if not real_dep or real_dep not in pkgs_data:
+                    continue  # it means this depends does not belong to the sorting context
+                else:
+                    dep_idx = sorted_names.get(real_dep)
+
+                    if dep_idx is not None and dep_idx + 1 > idx:
+                        idx = dep_idx + 1
+                    else:
+                        dep_idx = __add_dep_to_sort(real_dep, pkgs_data, sorted_names, not_sorted, provided_map)
+                        if dep_idx + 1 > idx:
+                            idx = dep_idx + 1
+
+        sorted_names[pkgname] = idx
+        return idx
+
+
+def sort(pkgs: Iterable[str], pkgs_data: Dict[str, dict], provided_map: Dict[str, Set[str]] = None) -> List[Tuple[str, str]]:
+    sorted_list, sorted_names, not_sorted = [], set(), set()
+    provided = provided_map if provided_map else {}
+
+    # add all packages with no dependencies first
+    for pkgname in pkgs:
+        data = pkgs_data[pkgname]
+        if not provided_map and data['p']:  # mapping provided if reeded
+            for p in data['p']:
+                provided[p] = {pkgname}
+
+        if not data['d']:
+            sorted_list.append(pkgname)
+            sorted_names.add(pkgname)
+        else:
+            not_sorted.add(pkgname)
+
+    deps_map, not_deps_available = {}, set()
+    for pkg in not_sorted:  # generating a dependency map with only the dependencies among the informed packages
+        pkgsdeps = set()
+        data = pkgs_data[pkg]
+        for dep in data['d']:
+            providers = provided.get(dep)
+
+            if providers:
+                for p in providers:
+                    if p in pkgs:
+                        pkgsdeps.add(p)
+
+        if pkgsdeps:
+            deps_map[pkg] = pkgsdeps
+        else:
+            not_deps_available.add(pkg)
+            sorted_list.append(pkg)
+            sorted_names.add(pkg)
+
+    for pkg in not_deps_available:  # removing from not_sorted
+        not_sorted.remove(pkg)
+
+    while not_sorted:
+        sorted_in_round = set()
+
+        for pkg in not_sorted:
+            idx = _index_pkg(pkg, sorted_list, sorted_names, deps_map, ignore_not_sorted=False)
+
+            if idx >= 0:
+                sorted_in_round.add(pkg)
+                sorted_names.add(pkg)
+                sorted_list.insert(idx, pkg)
+
+        for pkg in sorted_in_round:
+            not_sorted.remove(pkg)
+
+        if not_sorted and not sorted_in_round:  # it means there are cyclic deps
+            break
+
+    if not_sorted:  # it means there are cyclic deps
+        # filtering deps already mapped
+        for pkg in not_sorted:
+            deps_map[pkg] = deps_map[pkg].difference(sorted_names)
+
+        dep_lvl_map = {}  # holds the diff between the number of dependents per package and its dependencies
+        for pkg in not_sorted:
+            dependents = 0
+            for pkg2 in not_sorted:
+                if pkg != pkg2 and pkg in deps_map[pkg2]:
+                    dependents += 1
+
+            dep_lvl_map[pkg] = dependents - len(deps_map[pkg])
+
+        sorted_by_less_deps = [*not_sorted]
+        sorted_by_less_deps.sort(key=lambda o: dep_lvl_map[o], reverse=True)  # sorting by higher dep level
+
+        for pkg in sorted_by_less_deps:
+            idx = _index_pkg(pkg, sorted_list, sorted_names, deps_map, ignore_not_sorted=True)
+            sorted_names.add(pkg)
+            sorted_list.insert(idx, pkg)
+
+    # putting arch pkgs in the end:
+    aur_pkgs = None
+    res = []
+
+    for name in sorted_list:
+        repo = pkgs_data[name]['r']
+        if repo == 'arch':
+            if not aur_pkgs:
+                aur_pkgs = []
+
+            aur_pkgs.append((name, 'arch'))
+        else:
+            res.append((name, repo))
+
+    if aur_pkgs:
+        res.extend(aur_pkgs)
+
+    return res
+
+
+def _index_pkg(name: str, sorted_list: List[str], sorted_names: Set[str], deps_map: Dict[str, Set[str]], ignore_not_sorted: bool) -> int:
+    deps_to_check_idx = set()
+    for dep in deps_map[name]:
+        if dep in sorted_names:
+            deps_to_check_idx.add(dep)
+        elif not ignore_not_sorted:
+            return -1
+
+    if not deps_to_check_idx:
+        return len(sorted_list)
+    else:
+        idxs = {sorted_list.index(dep) for dep in deps_to_check_idx}
+        return max(idxs) + 1

bauh/gems/arch/updates.py

@@ -0,0 +1,425 @@
+import logging
+import time
+from threading import Thread
+from typing import Dict, Set, List, Tuple, Iterable
+
+from bauh.api.abstract.controller import UpgradeRequirements, UpgradeRequirement
+from bauh.api.abstract.handler import ProcessWatcher
+from bauh.gems.arch import pacman, sorting
+from bauh.gems.arch.aur import AURClient
+from bauh.gems.arch.dependencies import DependenciesAnalyser
+from bauh.gems.arch.exceptions import PackageNotFoundException
+from bauh.gems.arch.model import ArchPackage
+from bauh.view.util.translation import I18n
+
+
+class UpdateRequirementsContext:
+
+    def __init__(self, to_update: Dict[str, ArchPackage], repo_to_update: Dict[str, ArchPackage],
+                 aur_to_update: Dict[str, ArchPackage], repo_to_install: Dict[str, ArchPackage],
+                 aur_to_install: Dict[str, ArchPackage], to_install: Dict[str, ArchPackage],
+                 pkgs_data: Dict[str, dict], cannot_upgrade: Dict[str, UpgradeRequirement],
+                 to_remove: Dict[str, UpgradeRequirement], installed_names: Set[str], provided_map: Dict[str, Set[str]],
+                 aur_index: Set[str], arch_config: dict, remote_provided_map: Dict[str, Set[str]], remote_repo_map: Dict[str, str],
+                 root_password: str):
+        self.to_update = to_update
+        self.repo_to_update = repo_to_update
+        self.aur_to_update = aur_to_update
+        self.repo_to_install = repo_to_install
+        self.aur_to_install = aur_to_install
+        self.pkgs_data = pkgs_data
+        self.cannot_upgrade = cannot_upgrade
+        self.root_password = root_password
+        self.installed_names = installed_names
+        self.provided_map = provided_map
+        self.to_remove = to_remove
+        self.to_install = to_install
+        self.aur_index = aur_index
+        self.arch_config = arch_config
+        self.remote_provided_map = remote_provided_map
+        self.remote_repo_map = remote_repo_map
+
+
+class UpdatesSummarizer:
+
+    def __init__(self, aur_client: AURClient, i18n: I18n, logger: logging.Logger, deps_analyser: DependenciesAnalyser, watcher: ProcessWatcher):
+        self.aur_client = aur_client
+        self.i18n = i18n
+        self.logger = logger
+        self.watcher = watcher
+        self.deps_analyser = deps_analyser
+
+    def _fill_aur_pkg_update_data(self, pkg: ArchPackage, output: dict):
+        output[pkg.name] = self.aur_client.map_update_data(pkg.get_base_name(), pkg.latest_version)
+
+    def _handle_conflict_both_to_install(self, pkg1: str, pkg2: str, context: UpdateRequirementsContext):
+        for src_pkg in {p for p, data in context.pkgs_data.items() if
+                        data['d'] and pkg1 in data['d'] or pkg2 in data['d']}:
+            if src_pkg not in context.cannot_upgrade:
+                reason = self.i18n['arch.update_summary.to_install.dep_conflict'].format("'{}'".format(pkg1),
+                                                                                         "'{}'".format(pkg2))
+                context.cannot_upgrade[src_pkg] = UpgradeRequirement(context.to_update[src_pkg], reason)
+
+            del context.to_update[src_pkg]
+
+            if src_pkg in context.repo_to_update:
+                del context.repo_to_update[src_pkg]
+            else:
+                del context.aur_to_update[src_pkg]
+
+            del context.pkgs_data[src_pkg]
+
+        for p in (pkg1, pkg2):
+            if p in context.to_install:
+                del context.to_install[p]
+
+                if p in context.repo_to_install:
+                    del context.repo_to_install[p]
+                else:
+                    del context.aur_to_install[p]
+
+    def _handle_conflict_to_update_and_to_install(self, pkg1: str, pkg2: str, pkg1_to_install: bool, context: UpdateRequirementsContext):
+        to_install, to_update = (pkg1, pkg2) if pkg1_to_install else (pkg2, pkg1)
+        to_install_srcs = {p for p, data in context.pkgs_data.items() if data['d'] and to_install in data['d']}
+
+        if to_update not in context.cannot_upgrade:
+            srcs_str = ', '.join(("'{}'".format(p) for p in to_install_srcs))
+            reason = self.i18n['arch.update_summary.to_update.conflicts_dep'].format("'{}'".format(to_install),
+                                                                                     srcs_str)
+            context.cannot_upgrade[to_install] = UpgradeRequirement(context.to_update[to_update], reason)
+
+        if to_update in context.to_update:
+            del context.to_update[to_update]
+
+        for src_pkg in to_install_srcs:
+            src_to_install = src_pkg in context.to_install
+            pkg = context.to_install[src_pkg] if src_to_install else context.to_update[src_pkg]
+            if src_pkg not in context.cannot_upgrade:
+                reason = self.i18n['arch.update_summary.to_update.dep_conflicts'].format("'{}'".format(to_install),
+                                                                                         "'{}'".format(to_update))
+                context.cannot_upgrade[src_pkg] = UpgradeRequirement(pkg, reason)
+
+            if src_to_install:
+                del context.to_install[src_pkg]
+
+                if src_pkg in context.repo_to_install:
+                    del context.repo_to_install[src_pkg]
+                else:
+                    del context.aur_to_install[src_pkg]
+            else:
+                del context.to_update[src_pkg]
+
+                if src_pkg in context.repo_to_update:
+                    del context.repo_to_update[src_pkg]
+                else:
+                    del context.aur_to_update[src_pkg]
+
+            del context.pkgs_data[src_pkg]
+
+        if to_install in context.to_install:
+            del context.to_install[to_install]
+
+    def _handle_conflict_both_to_update(self, pkg1: str, pkg2: str, context: UpdateRequirementsContext):
+        if pkg1 not in context.cannot_upgrade:
+            reason = "{} '{}'".format(self.i18n['arch.info.conflicts with'].capitalize(), pkg2)
+            context.cannot_upgrade[pkg1] = UpgradeRequirement(pkg=context.to_update[pkg1], reason=reason)
+
+        if pkg2 not in context.cannot_upgrade:
+            reason = "{} '{}'".format(self.i18n['arch.info.conflicts with'].capitalize(), pkg1)
+            context.cannot_upgrade[pkg2] = UpgradeRequirement(pkg=context.to_update[pkg2], reason=reason)
+
+        for p in (pkg1, pkg2):
+            if p in context.to_update:
+                del context.to_update[p]
+
+                if p in context.repo_to_update:
+                    del context.repo_to_update[p]
+                else:
+                    del context.aur_to_update[p]
+
+    def _filter_and_map_conflicts(self, context: UpdateRequirementsContext) -> Dict[str, str]:
+        root_conflict = {}
+        mutual_conflicts = {}
+
+        for p, data in context.pkgs_data.items():
+            if data['c']:
+                for c in data['c']:
+                    if c and c in context.installed_names:
+                        # source = provided_map[c]
+                        root_conflict[c] = p
+
+                        if (p, c) in root_conflict.items():
+                            mutual_conflicts[c] = p
+
+        if mutual_conflicts:
+            for pkg1, pkg2 in mutual_conflicts.items():
+                pkg1_to_install = pkg1 in context.to_install
+                pkg2_to_install = pkg2 in context.to_install
+
+                if pkg1_to_install and pkg2_to_install:  # remove both from to install and mark their source packages as 'cannot_update'
+                    self._handle_conflict_both_to_install(pkg1, pkg2, context)
+                elif (pkg1_to_install and not pkg2_to_install) or (not pkg1_to_install and pkg2_to_install):
+                    self._handle_conflict_to_update_and_to_install(pkg1, pkg2, pkg1_to_install, context)
+                else:
+                    self._handle_conflict_both_to_update(pkg1, pkg2, context)  # adding both to the 'cannot update' list
+
+            for pkg1, pkg2 in mutual_conflicts.items():  # removing conflicting packages from the packages selected to update
+                for p in (pkg1, pkg2):
+                    for c in context.pkgs_data[p]['c']:
+                        # source = provided_map[c]
+                        if c in root_conflict:
+                            del root_conflict[c]
+
+                    if p in context.pkgs_data:
+                        del context.pkgs_data[p]
+
+        return root_conflict
+
+    def _fill_conflicts(self, context: UpdateRequirementsContext, blacklist: Iterable[str] = None):
+        self.logger.info("Checking conflicts")
+
+        root_conflict = self._filter_and_map_conflicts(context)
+
+        sub_conflict = pacman.get_dependencies_to_remove(root_conflict.keys(), context.root_password) if root_conflict else None
+
+        to_remove_map = {}
+        if sub_conflict:
+            for dep, source in sub_conflict.items():
+                if dep not in to_remove_map and (not blacklist or dep not in blacklist):
+                    req = ArchPackage(name=dep, installed=True, i18n=self.i18n)
+                    to_remove_map[dep] = req
+                    reason = "{} '{}'".format(self.i18n['arch.info.depends on'].capitalize(), source)
+                    context.to_remove[dep] = UpgradeRequirement(req, reason)
+
+        if root_conflict:
+            for dep, source in root_conflict.items():
+                if dep not in to_remove_map and (not blacklist or dep not in blacklist):
+                    req = ArchPackage(name=dep, installed=True, i18n=self.i18n)
+                    to_remove_map[dep] = req
+                    reason = "{} '{}'".format(self.i18n['arch.info.conflicts with'].capitalize(), source)
+                    context.to_remove[dep] = UpgradeRequirement(req, reason)
+
+        if to_remove_map:
+            for name in to_remove_map.keys():  # upgrading lists
+                if name in context.pkgs_data:
+                    del context.pkgs_data[name]
+
+                if name in context.aur_to_update:
+                    del context.aur_to_update[name]
+
+                if name in context.repo_to_update:
+                    del context.repo_to_update[name]
+
+            removed_size = pacman.get_installed_size([*to_remove_map.keys()])
+
+            if removed_size:
+                for name, size in removed_size.items():
+                    if size is not None:
+                        req = context.to_remove.get(name)
+                        if req:
+                            req.extra_size = size
+
+    def _map_and_add_package(self, pkg_data: Tuple[str, str], idx: int, output: dict):
+        version = None
+
+        if pkg_data[1] == 'arch':
+            try:
+                info = self.aur_client.get_src_info(pkg_data[0])
+
+                if info:
+                    version = info.get('pkgver')
+
+                    if not version:
+                        self.logger.warning("No version declared in SRCINFO of '{}'".format(pkg_data[0]))
+                else:
+                    self.logger.warning("Could not retrieve the SRCINFO for '{}'".format(pkg_data[0]))
+            except:
+                self.logger.warning("Could not retrieve the SRCINFO for '{}'".format(pkg_data[0]))
+        else:
+            version = pacman.get_version_for_not_installed(pkg_data[0])
+
+        output[idx] = ArchPackage(name=pkg_data[0], version=version, latest_version=version, repository=pkg_data[1], i18n=self.i18n)
+
+    def _fill_to_install(self, context: UpdateRequirementsContext) -> bool:
+        ti = time.time()
+        self.logger.info("Discovering updates missing packages")
+        deps_data, deps_checked = {}, set()
+        deps = self.deps_analyser.map_missing_deps(pkgs_data=context.pkgs_data,
+                                                   provided_map=context.provided_map,
+                                                   aur_index=context.aur_index,
+                                                   deps_checked=deps_checked,
+                                                   sort=True,
+                                                   deps_data=deps_data,
+                                                   remote_provided_map=context.remote_provided_map,
+                                                   remote_repo_map=context.remote_repo_map,
+                                                   watcher=self.watcher)
+
+        if deps is None:
+            tf = time.time()
+            self.logger.info("It took {0:.2f} seconds to retrieve required upgrade packages".format(tf - ti))
+            return False  # the user called the process off
+
+        if deps:  # filtering selected packages
+            selected_names = {p for p in context.to_update}
+            deps = [dep for dep in deps if dep[0] not in selected_names]
+
+            if deps:
+                sorted_pkgs = {}
+                aur_to_install_data = {}
+                all_to_install_data = {}
+
+                for idx, dep in enumerate(deps):
+                    data = deps_data[dep[0]]
+                    pkg = ArchPackage(name=dep[0], version=data['v'], latest_version=data['v'], repository=dep[1], i18n=self.i18n)
+                    sorted_pkgs[idx] = pkg
+                    context.to_install[dep[0]] = pkg
+
+                    if pkg.repository == 'arch':
+                        context.aur_to_install[pkg.name] = pkg
+                        aur_to_install_data[pkg.name] = data
+                    else:
+                        context.repo_to_install[pkg.name] = pkg
+
+                if context.repo_to_install:
+                    all_to_install_data.update(pacman.map_updates_data(context.repo_to_install.keys()))
+
+                if aur_to_install_data:
+                    all_to_install_data.update(aur_to_install_data)
+
+                if all_to_install_data:
+                    context.pkgs_data.update(all_to_install_data)
+                    self._fill_conflicts(context, context.to_remove.keys())
+
+        tf = time.time()
+        self.logger.info("It took {0:.2f} seconds to retrieve required upgrade packages".format(tf - ti))
+        return True
+
+    def __fill_provided_map(self, context: UpdateRequirementsContext):
+        ti = time.time()
+        self.logger.info("Filling provided names")
+        context.installed_names = pacman.list_installed_names()
+        installed_to_ignore = set()
+
+        for pkgname in context.to_update:
+            pacman.fill_provided_map(pkgname, pkgname, context.provided_map)
+            installed_to_ignore.add(pkgname)
+
+            pdata = context.pkgs_data.get(pkgname)
+            if pdata and pdata['p']:
+                pacman.fill_provided_map('{}={}'.format(pkgname, pdata['v']), pkgname, context.provided_map)
+                for p in pdata['p']:
+                    pacman.fill_provided_map(p, pkgname, context.provided_map)
+                    split_provided = p.split('=')
+
+                    if len(split_provided) > 1 and split_provided[0] != p:
+                        pacman.fill_provided_map(split_provided[0], pkgname, context.provided_map)
+
+        if installed_to_ignore:  # filling the provided names of the installed
+            installed_to_query = context.installed_names.difference(installed_to_ignore)
+
+            if installed_to_query:
+                context.provided_map.update(pacman.map_provided(remote=False, pkgs=installed_to_query))
+
+        tf = time.time()
+        self.logger.info("Filling provided names took {0:.2f} seconds".format(tf - ti))
+
+    def __fill_aur_index(self, context: UpdateRequirementsContext):
+        if context.arch_config['arch']:
+            self.logger.info("Loading AUR index")
+            names = self.aur_client.read_index()
+
+            if names:
+                context.aur_index.update(names)
+                self.logger.info("AUR index loaded on the context")
+
+    def _map_requirement(self, pkg: ArchPackage, context: UpdateRequirementsContext, installed_sizes: Dict[str, int] = None) -> UpgradeRequirement:
+        requirement = UpgradeRequirement(pkg)
+
+        if pkg.repository != 'arch':
+            data = context.pkgs_data[pkg.name]
+            requirement.required_size = data['ds']
+            requirement.extra_size = data['s']
+    
+            current_size = installed_sizes.get(pkg.name) if installed_sizes else None
+
+            if current_size is not None and data['s']:
+                requirement.extra_size = data['s'] - current_size
+
+        return requirement
+
+    def summarize(self, pkgs: List[ArchPackage], root_password: str, arch_config: dict) -> UpgradeRequirements:
+        res = UpgradeRequirements([], [], [], [])
+
+        remote_provided_map = pacman.map_provided(remote=True)
+        remote_repo_map = pacman.map_repositories()
+        context = UpdateRequirementsContext(to_update={}, repo_to_update={}, aur_to_update={}, repo_to_install={},
+                                            aur_to_install={}, to_install={}, pkgs_data={}, cannot_upgrade={},
+                                            to_remove={}, installed_names=set(), provided_map={}, aur_index=set(),
+                                            arch_config=arch_config, root_password=root_password,
+                                            remote_provided_map=remote_provided_map, remote_repo_map=remote_repo_map)
+        self.__fill_aur_index(context)
+
+        aur_data = {}
+        aur_srcinfo_threads = []
+        for p in pkgs:
+            context.to_update[p.name] = p
+            if p.repository == 'arch':
+                context.aur_to_update[p.name] = p
+                t = Thread(target=self._fill_aur_pkg_update_data, args=(p, aur_data), daemon=True)
+                t.start()
+                aur_srcinfo_threads.append(t)
+            else:
+                context.repo_to_update[p.name] = p
+
+        if context.aur_to_update:
+            for t in aur_srcinfo_threads:
+                t.join()
+
+        self.logger.info("Filling updates data")
+
+        if context.repo_to_update:
+            context.pkgs_data.update(pacman.map_updates_data(context.repo_to_update.keys()))
+
+        if aur_data:
+            context.pkgs_data.update(aur_data)
+
+        self.__fill_provided_map(context)
+
+        if context.pkgs_data:
+            self._fill_conflicts(context)
+
+        try:
+            if not self._fill_to_install(context):
+                self.logger.info("The operation was cancelled by the user")
+                return
+        except PackageNotFoundException as e:
+            self.logger.error("Package '{}' not found".format(e.name))
+            return
+
+        if context.to_update:
+            installed_sizes = pacman.get_installed_size(list(context.to_update.keys()))
+
+            sorted_pkgs = []
+
+            if context.repo_to_update:  # only sorting by name ( pacman already knows the best order to perform the upgrade )
+                sorted_pkgs.extend(context.repo_to_update.values())
+                sorted_pkgs.sort(key=lambda pkg: pkg.name)
+
+            if context.aur_to_update:  # adding AUR packages in the end
+                sorted_aur = sorting.sort(context.aur_to_update.keys(), context.pkgs_data, context.provided_map)
+
+                for aur_pkg in sorted_aur:
+                    sorted_pkgs.append(context.aur_to_update[aur_pkg[0]])
+
+            res.to_upgrade = [self._map_requirement(pkg, context, installed_sizes) for pkg in sorted_pkgs]
+
+        if context.to_remove:
+            res.to_remove = [p for p in context.to_remove.values()]
+
+        if context.cannot_upgrade:
+            res.cannot_upgrade = [d for d in context.cannot_upgrade.values()]
+
+        if context.to_install:
+            res.to_install = [self._map_requirement(p, context) for p in context.to_install.values()]
+
+        return res

bauh/gems/arch/worker.py

@@ -2,18 +2,22 @@ import logging
 import os
 import re
 import time
-from multiprocessing import Process
+import traceback
 from pathlib import Path
 from threading import Thread
 
 import requests
 
 from bauh.api.abstract.context import ApplicationContext
-from bauh.commons.system import run_cmd
+from bauh.api.abstract.handler import TaskManager
+from bauh.commons.html import bold
+from bauh.commons.system import run_cmd, new_root_subprocess, ProcessHandler
 from bauh.gems.arch import pacman, disk, CUSTOM_MAKEPKG_FILE, CONFIG_DIR, BUILD_DIR, \
-    AUR_INDEX_FILE, config
+    AUR_INDEX_FILE, get_icon_path, database, mirrors
+from bauh.gems.arch.aur import URL_INDEX
+from bauh.gems.arch.model import ArchPackage
+from bauh.view.util.translation import I18n
 
-URL_INDEX = 'https://aur.archlinux.org/packages.gz'
 URL_INFO = 'https://aur.archlinux.org/rpc/?v=5&type=info&arg={}'
 
 GLOBAL_MAKEPKG = '/etc/makepkg.conf'
@@ -27,6 +31,7 @@ class AURIndexUpdater(Thread):
     def __init__(self, context: ApplicationContext):
         super(AURIndexUpdater, self).__init__(daemon=True)
         self.http_client = context.http_client
+        self.i18n = context.i18n
         self.logger = context.logger
 
     def run(self):
@@ -50,39 +55,102 @@ class AURIndexUpdater(Thread):
         except requests.exceptions.ConnectionError:
             self.logger.warning('No internet connection: could not pre-index packages')
 
+        self.logger.info("Finished")
 
-class ArchDiskCacheUpdater(Thread if bool(os.getenv('BAUH_DEBUG', 0)) else Process):
 
-    def __init__(self, logger: logging.Logger, disk_cache: bool):
+class ArchDiskCacheUpdater(Thread):
+
+    def __init__(self, task_man: TaskManager, arch_config: dict, i18n: I18n, logger: logging.Logger):
         super(ArchDiskCacheUpdater, self).__init__(daemon=True)
         self.logger = logger
-        self.disk_cache = disk_cache
+        self.task_man = task_man
+        self.task_id = 'arch_cache_up'
+        self.i18n = i18n
+        self.prepared = 0
+        self.prepared_template = self.i18n['arch.task.disk_cache.prepared'] + ': {}/ {}'
+        self.indexed = 0
+        self.indexed_template = self.i18n['arch.task.disk_cache.indexed'] + ': {}/ {}'
+        self.to_index = 0
+        self.progress = 0  # progress is defined by the number of packages prepared and indexed
+        self.repositories = arch_config['repositories']
+        self.aur = arch_config['arch']
+
+    def update_prepared(self, pkgname: str, add: bool = True):
+        if add:
+            self.prepared += 1
+
+        sub = self.prepared_template.format(self.prepared, self.to_index)
+        progress = ((self.prepared + self.indexed) / self.progress) * 100 if self.progress > 0 else 0
+        self.task_man.update_progress(self.task_id, progress, sub)
+
+    def update_indexed(self, pkgname: str):
+        self.indexed += 1
+        sub = self.indexed_template.format(self.indexed, self.to_index)
+        progress = ((self.prepared + self.indexed) / self.progress) * 100 if self.progress > 0 else 0
+        self.task_man.update_progress(self.task_id, progress, sub)
 
     def run(self):
-        if self.disk_cache:
-            self.logger.info('Pre-caching installed AUR packages data to disk')
-            installed = pacman.list_and_map_installed()
+        if not any([self.aur, self.repositories]):
+            return
 
-            saved = 0
-            if installed and installed['not_signed']:
-                saved = disk.save_several({app for app in installed['not_signed']}, 'aur', overwrite=False)
+        ti = time.time()
+        self.task_man.register_task(self.task_id, self.i18n['arch.task.disk_cache'], get_icon_path())
 
-            self.logger.info('Pre-cached data of {} AUR packages to the disk'.format(saved))
+        self.logger.info('Pre-caching installed Arch packages data to disk')
+        installed = pacman.map_installed(repositories=self.repositories, aur=self.aur)
+
+        self.task_man.update_progress(self.task_id, 0, self.i18n['arch.task.disk_cache.reading'])
+        for k in ('signed', 'not_signed'):
+            installed[k] = {p for p in installed[k] if not os.path.exists(ArchPackage.disk_cache_path(p))}
+
+        saved = 0
+        pkgs = {*installed['signed'], *installed['not_signed']}
+
+        repo_map = {}
+
+        if installed['not_signed']:
+            repo_map.update({p: 'arch' for p in installed['not_signed']})
+
+        if installed['signed']:
+            repo_map.update(pacman.map_repositories(installed['signed']))
+
+        self.to_index = len(pkgs)
+        self.progress = self.to_index * 2
+        self.update_prepared(None, add=False)
+
+        saved += disk.save_several(pkgs, repo_map, when_prepared=self.update_prepared, after_written=self.update_indexed)
+        self.task_man.update_progress(self.task_id, 100, None)
+        self.task_man.finish_task(self.task_id)
+
+        tf = time.time()
+        time_msg = 'Took {0:.2f} seconds'.format(tf - ti)
+        self.logger.info('Pre-cached data of {} Arch packages to the disk. {}'.format(saved, time_msg))
 
 
 class ArchCompilationOptimizer(Thread):
 
-    def __init__(self, logger: logging.Logger):
+    def __init__(self, arch_config: dict, i18n: I18n, logger: logging.Logger, task_man: TaskManager = None):
         super(ArchCompilationOptimizer, self).__init__(daemon=True)
         self.logger = logger
+        self.i18n = i18n
         self.re_compress_xz = re.compile(r'#?\s*COMPRESSXZ\s*=\s*.+')
         self.re_compress_zst = re.compile(r'#?\s*COMPRESSZST\s*=\s*.+')
         self.re_build_env = re.compile(r'\s+BUILDENV\s*=.+')
         self.re_ccache = re.compile(r'!?ccache')
+        self.task_man = task_man
+        self.task_id = 'arch_make_optm'
+        self.optimizations = bool(arch_config['optimize'])
 
     def _is_ccache_installed(self) -> bool:
         return bool(run_cmd('which ccache', print_error=False))
 
+    def _update_progress(self, progress: float, substatus: str = None):
+        if self.task_man:
+            self.task_man.update_progress(self.task_id, progress, substatus)
+
+            if progress == 100:
+                self.task_man.finish_task(self.task_id)
+
     def optimize(self):
         ti = time.time()
         try:
@@ -115,6 +183,8 @@ class ArchCompilationOptimizer(Thread):
                 else:
                     optimizations.append('MAKEFLAGS="-j$(nproc)"')
 
+            self._update_progress(20)
+
             compress_xz = self.re_compress_xz.findall(custom_makepkg or global_makepkg)
 
             if compress_xz:
@@ -128,6 +198,8 @@ class ArchCompilationOptimizer(Thread):
             else:
                 optimizations.append('COMPRESSXZ=(xz -c -z - --threads=0)')
 
+            self._update_progress(40)
+
             compress_zst = self.re_compress_zst.findall(custom_makepkg or global_makepkg)
 
             if compress_zst:
@@ -141,6 +213,8 @@ class ArchCompilationOptimizer(Thread):
             else:
                 optimizations.append('COMPRESSZST=(zstd -c -z -q - --threads=0)')
 
+            self._update_progress(60)
+
             build_envs = self.re_build_env.findall(custom_makepkg or global_makepkg)
 
             if build_envs:
@@ -169,6 +243,8 @@ class ArchCompilationOptimizer(Thread):
                     self.logger.info('Adding a BUILDENV declaration')
                     optimizations.append('BUILDENV=(ccache)')
 
+            self._update_progress(80)
+
             if optimizations:
                 generated_by = '# <generated by bauh>\n'
                 custom_makepkg = custom_makepkg + '\n' + generated_by + '\n'.join(optimizations) + '\n'
@@ -185,13 +261,12 @@ class ArchCompilationOptimizer(Thread):
                     os.remove(CUSTOM_MAKEPKG_FILE)
 
             tf = time.time()
+            self._update_progress(100)
             self.logger.info("Optimizations took {0:.2f} seconds".format(tf - ti))
             self.logger.info('Finished')
 
     def run(self):
-        local_config = config.read_config(update_file=True)
-
-        if not local_config['optimize']:
+        if not self.optimizations:
             self.logger.info("Arch packages compilation optimizations are disabled")
 
             if os.path.exists(CUSTOM_MAKEPKG_FILE):
@@ -200,4 +275,113 @@ class ArchCompilationOptimizer(Thread):
 
             self.logger.info('Finished')
         else:
-           self.optimize()
+            if self.task_man:
+                self.task_man.register_task(self.task_id, self.i18n['arch.task.optimizing'].format(bold('makepkg.conf')), get_icon_path())
+
+            self.optimize()
+
+
+class RefreshMirrors(Thread):
+
+    def __init__(self, taskman: TaskManager, root_password: str, i18n: I18n, sort_limit: int, logger: logging.Logger):
+        super(RefreshMirrors, self).__init__(daemon=True)
+        self.taskman = taskman
+        self.i18n = i18n
+        self.logger = logger
+        self.root_password = root_password
+        self.task_id = "arch_mirrors"
+        self.sort_limit = sort_limit
+
+    def run(self):
+        self.logger.info("Refreshing mirrors")
+        self.taskman.register_task(self.task_id, self.i18n['arch.task.mirrors'], get_icon_path())
+
+        handler = ProcessHandler()
+        try:
+            success, output = handler.handle_simple(pacman.refresh_mirrors(self.root_password))
+
+            if success:
+
+                if self.sort_limit is not None and self.sort_limit >= 0:
+                    self.taskman.update_progress(self.task_id, 50, self.i18n['arch.custom_action.refresh_mirrors.status.updating'])
+                    try:
+                        handler.handle_simple(pacman.sort_fastest_mirrors(self.root_password, self.sort_limit))
+                    except:
+                        self.logger.error("Could not sort mirrors by speed")
+                        traceback.print_exc()
+
+                mirrors.register_sync(self.logger)
+            else:
+                self.logger.error("It was not possible to refresh mirrors")
+        except:
+            self.logger.error("It was not possible to refresh mirrors")
+            traceback.print_exc()
+
+        self.taskman.update_progress(self.task_id, 100, None)
+        self.taskman.finish_task(self.task_id)
+        self.logger.info("Finished")
+
+
+class SyncDatabases(Thread):
+
+    def __init__(self, taskman: TaskManager, root_password: str, i18n: I18n, logger: logging.Logger, refresh_mirrors: RefreshMirrors = None):
+        super(SyncDatabases, self).__init__(daemon=True)
+        self.task_man = taskman
+        self.i18n = i18n
+        self.taskman = taskman
+        self.task_id = "arch_dbsync"
+        self.root_password = root_password
+        self.refresh_mirrors = refresh_mirrors
+        self.logger = logger
+
+    def run(self) -> None:
+        self.logger.info("Synchronizing databases")
+        self.taskman.register_task(self.task_id, self.i18n['arch.sync_databases.substatus'], get_icon_path())
+
+        if self.refresh_mirrors and self.refresh_mirrors.is_alive():
+            self.taskman.update_progress(self.task_id, 0, self.i18n['arch.task.sync_databases.waiting'])
+            self.refresh_mirrors.join()
+
+        progress = 10
+        dbs = pacman.get_databases()
+        self.taskman.update_progress(self.task_id, progress, None)
+
+        if dbs:
+            inc = 90 / len(dbs)
+            try:
+                p = new_root_subprocess(['pacman', '-Syy'], self.root_password)
+
+                dbs_read, last_db = 0, None
+
+                for o in p.stdout:
+                    line = o.decode().strip()
+
+                    if line and line.startswith('downloading'):
+                        db = line.split(' ')[1].strip()
+
+                        if last_db is None or last_db != db:
+                            last_db = db
+                            dbs_read += 1
+                            progress = dbs_read * inc
+                        else:
+                            progress += 0.25
+
+                        self.taskman.update_progress(self.task_id, progress, self.i18n['arch.task.sync_sb.status'].format(db))
+
+                for o in p.stderr:
+                    o.decode()
+
+                p.wait()
+
+                if p.returncode == 0:
+                    database.register_sync(self.logger)
+                else:
+                    self.logger.error("Could not synchronize database")
+
+            except:
+                self.logger.info("Error while synchronizing databases")
+                traceback.print_exc()
+
+        self.taskman.update_progress(self.task_id, 100, None)
+        self.taskman.finish_task(self.task_id)
+        self.logger.info("Finished")