| # Copyright 2010 Gentoo Foundation |
| # Distributed under the terms of the GNU General Public License v2 |
| |
| __all__ = ( |
| 'UseManager', |
| ) |
| |
| from portage import os |
| from portage.dep import ExtendedAtomDict, remove_slot |
| from portage.util import grabfile, grabdict_package, stack_lists |
| from portage.versions import cpv_getkey |
| |
| from portage.package.ebuild._config.helper import ordered_by_atom_specificity |
| |
| class UseManager(object): |
| |
| def __init__(self, profiles, abs_user_config, user_config=True): |
| # file variable |
| #-------------------------------- |
| # profiles |
| #-------------------------------- |
| # use.mask _usemask_list |
| # use.force _useforce_list |
| # package.use.mask _pusemask_list |
| # package.use _pkgprofileuse |
| # package.use.force _puseforce_list |
| #-------------------------------- |
| # user config |
| #-------------------------------- |
| # package.use _pusedict |
| |
| # Dynamic variables tracked by the config class |
| #-------------------------------- |
| # profiles |
| #-------------------------------- |
| # usemask |
| # useforce |
| #-------------------------------- |
| # user config |
| #-------------------------------- |
| # puse |
| |
| self._usemask_list = self._parse_profile_files_to_list("use.mask", profiles) |
| self._useforce_list = self._parse_profile_files_to_list("use.force", profiles) |
| self._pusemask_list = self._parse_profile_files_to_dict("package.use.mask", profiles) |
| self._pkgprofileuse = self._parse_profile_files_to_dict("package.use", profiles, juststrings=True) |
| self._puseforce_list = self._parse_profile_files_to_dict("package.use.force", profiles) |
| |
| self._pusedict = self._parse_user_files_to_extatomdict("package.use", abs_user_config, user_config) |
| |
| def _parse_user_files_to_extatomdict(self, file_name, location, user_config): |
| ret = ExtendedAtomDict(dict) |
| if user_config: |
| pusedict = grabdict_package( |
| os.path.join(location, file_name), recursive=1, allow_wildcard=True) |
| for k, v in pusedict.items(): |
| ret.setdefault(k.cp, {})[k] = v |
| |
| return ret |
| |
| def _parse_profile_files_to_list(self, file_name, locations): |
| return tuple( |
| tuple(grabfile(os.path.join(x, file_name), recursive=1)) |
| for x in locations) |
| |
| def _parse_profile_files_to_dict(self, file_name, locations, juststrings=False): |
| ret = [] |
| raw = [grabdict_package(os.path.join(x, file_name), |
| juststrings=juststrings, recursive=1) for x in locations] |
| for rawdict in raw: |
| cpdict = {} |
| for k, v in rawdict.items(): |
| cpdict.setdefault(k.cp, {})[k] = v |
| ret.append(cpdict) |
| return ret |
| |
| def getUseMask(self, pkg=None): |
| if pkg is None: |
| return frozenset(stack_lists( |
| self._usemask_list, incremental=True)) |
| |
| cp = getattr(pkg, "cp", None) |
| if cp is None: |
| cp = cpv_getkey(remove_slot(pkg)) |
| usemask = [] |
| for i, pusemask_dict in enumerate(self._pusemask_list): |
| if self._usemask_list[i]: |
| usemask.append(self._usemask_list[i]) |
| cpdict = pusemask_dict.get(cp) |
| if cpdict: |
| pkg_usemask = ordered_by_atom_specificity(cpdict, pkg) |
| if pkg_usemask: |
| usemask.extend(pkg_usemask) |
| return frozenset(stack_lists(usemask, incremental=True)) |
| |
| def getUseForce(self, pkg=None): |
| if pkg is None: |
| return frozenset(stack_lists( |
| self._useforce_list, incremental=True)) |
| |
| cp = getattr(pkg, "cp", None) |
| if cp is None: |
| cp = cpv_getkey(remove_slot(pkg)) |
| useforce = [] |
| for i, puseforce_dict in enumerate(self._puseforce_list): |
| if self._useforce_list[i]: |
| useforce.append(self._useforce_list[i]) |
| cpdict = puseforce_dict.get(cp) |
| if cpdict: |
| pkg_useforce = ordered_by_atom_specificity(cpdict, pkg) |
| if pkg_useforce: |
| useforce.extend(pkg_useforce) |
| return frozenset(stack_lists(useforce, incremental=True)) |
| |
| def getPUSE(self, pkg): |
| cp = getattr(pkg, "cp", None) |
| if cp is None: |
| cp = cpv_getkey(remove_slot(pkg)) |
| ret = "" |
| cpdict = self._pusedict.get(cp) |
| if cpdict: |
| puse_matches = ordered_by_atom_specificity(cpdict, pkg) |
| if puse_matches: |
| puse_list = [] |
| for x in puse_matches: |
| puse_list.extend(x) |
| ret = " ".join(puse_list) |
| return ret |
| |
| def extract_global_USE_changes(self, old=""): |
| ret = old |
| cpdict = self._pusedict.get("*/*") |
| if cpdict is not None: |
| v = cpdict.pop("*/*", None) |
| if v is not None: |
| ret = " ".join(v) |
| if old: |
| ret = old + " " + ret |
| if not cpdict: |
| #No tokens left in atom_license_map, remove it. |
| del self._pusedict["*/*"] |
| return ret |