path: root/pym/gentoolkit/enalyze/lib.py

#!/usr/bin/python
#
# Copyright 2010 Brian Dolbec <brian.dolbec@gmail.com>
# Copyright(c) 2010, Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
#


"""Provides support functions to enalyze modules"""

from gentoolkit import errors
from gentoolkit.keyword import reduce_keywords
from gentoolkit.flag import (
    reduce_flags,
    get_flags,
    get_all_cpv_use,
    filter_flags,
    get_installed_use,
    defaulted_flags,
)

# from gentoolkit.package import Package

import portage


class FlagAnalyzer:
    """Specialty functions for analysing an installed package's
    USE flags.  Can be used for single or mulitple use without
    needing to be reset unless the system USE flags are changed.

    @type system: list or set
    @param system: the default system USE flags.
    @type _get_flags: function
    @param _get_flags: Normally defaulted, can be overriden for testing
    @type _get_used: function
    @param _get_used: Normally defaulted, can be overriden for testing
    """

    def __init__(
        self,
        system,
        filter_defaults=False,
        target="USE",
        _get_flags=get_flags,
        _get_used=get_installed_use,
    ):
        self.get_flags = _get_flags
        self.get_used = _get_used
        self.filter_defaults = filter_defaults
        self.target = target
        self.reset(system)

    def reset(self, system):
        """Resets the internal system USE flags and use_expand variables
        to the new setting. The use_expand variable is handled internally.

        @type system: list or set
        @param system: the default system USE flags.
        """
        self.system = set(system)
        self.use_expand = portage.settings["USE_EXPAND"].lower().split()

    def analyse_cpv(self, cpv):
        """Gets all relavent USE flag info for a cpv and breaks them down
        into 3 sets, plus (package.use enabled), minus ( package.use disabled),
        unset.

        @param cpv: string. 'cat/pkg-ver'
        @rtype tuple of sets
        @return (plus, minus, unset) sets of USE flags
        """
        installed = set(self.get_used(cpv, self.target))
        _iuse = self.get_flags(cpv)
        iuse = set(reduce_flags(_iuse))
        iuse_defaults = defaulted_flags(_iuse)
        return self._analyse(installed, iuse, iuse_defaults)

    def _analyse(self, installed, iuse, iuse_defaults):
        """Analyzes the supplied info and returns the flag settings
        that differ from the defaults

        @type installed: set
        @param installed: the installed with use flags
        @type iuse: set
        @param iuse: the current ebuilds IUSE
        """
        defaults = self.system.intersection(iuse)
        # update defaults with iuse_defaults
        defaults.update(iuse_defaults["+"])
        defaults = defaults.difference(iuse_defaults["-"])
        usedflags = iuse.intersection(set(installed))
        if self.filter_defaults:
            plus = usedflags.difference(defaults)
        else:
            plus = usedflags
        minus = defaults.difference(usedflags)
        unset = iuse.difference(defaults, plus, minus)
        cleaned_unset = self.remove_expanding(unset)
        return (plus, minus, cleaned_unset)

    def analyse_pkg(self, pkg):
        """Gets all relevent USE flag info for a pkg and breaks them down
        into 3 sets, plus (package.use enabled), minus ( package.use disabled),
        unset.

        @param pkg: gentoolkit.package.Package object
        @rtype tuple of sets
        @return (plus, minus, unset) sets of USE flags
        """
        installed = set(self.pkg_used(pkg))
        # print("installed =", installed)
        _iuse = self.pkg_flags(pkg)
        iuse = set(reduce_flags(_iuse))
        iuse_defaults = defaulted_flags(_iuse)
        # print("iuse =", iuse)
        return self._analyse(installed, iuse, iuse_defaults)

    def pkg_used(self, pkg):
        if self.target == "USE":
            return pkg.use().split()
        return pkg.environment(self.target).split()

    def pkg_flags(self, pkg):
        final_use, use_expand_hidden, usemasked, useforced = get_all_cpv_use(pkg.cpv)
        flags = pkg.environment("IUSE", prefer_vdb=False).split()
        return filter_flags(flags, use_expand_hidden, usemasked, useforced)

    def redundant(self, cpv, iuse):
        """Checks for redundant settings.
        future function. Not yet implemented.
        """
        pass

    def remove_expanding(self, flags):
        """Remove unwanted USE_EXPAND flags
        from unset IUSE sets

        @param flags: short list or set of USE flags
        @rtype set
        @return USE flags
        """
        _flags = set(flags)
        for expander in self.use_expand:
            for flag in flags:
                if expander in flag:
                    _flags.remove(flag)
            if not _flags:
                break
        return _flags


class KeywordAnalyser:
    """Specialty functions for analysing the installed package db for
    keyword useage and the packages that used them.

    Note: should be initialized with the internal set_order() before use.
    See internal set_order() for more details.
    This class of functions can be used for single cpv checks or
    used repeatedly for an entire package db.

    @type  arch: string
    @param arch: the system ARCH setting
    @type  accept_keywords: list
    @param accept_keywords: eg. ['x86', '~x86']
    @type  get_aux: function, defaults to: portage.db[portage.root]["vartree"].dbapi.aux_get
    @param vardb: vardb class of functions, needed=aux_get()
            to return => KEYWORDS & USE flags for a cpv
            = aux_get(cpv, ["KEYWORDS", "USE"])
    """

    # parsing order to determine appropriate keyword used for installation
    normal_order = ["stable", "testing", "prefix", "testing_prefix", "missing"]
    prefix_order = ["prefix", "testing_prefix", "stable", "testing", "missing"]
    parse_range = list(range(len(normal_order)))

    def __init__(
        self, arch, accept_keywords, vardb=portage.db[portage.root]["vartree"].dbapi
    ):
        self.arch = arch
        self.accept_keywords = accept_keywords
        self.vardb = vardb
        self.prefix = ""
        self.parse_order = None
        self.check_key = {
            "stable": self._stable,
            "testing": self._testing,
            "prefix": self._prefix,
            "testing_prefix": self._testing_prefix,
            "missing": self._missing,
        }
        self.mismatched = []

    def determine_keyword(self, keywords, used, cpv):
        """Determine the keyword from the installed USE flags and
        the KEYWORDS that was used to install a package.

        @param keywords: list of keywords available to install a pkg
        @param used: list of USE flalgs recorded for the installed pkg
        @rtype: string
        @return a keyword or null string
        """
        used = set(used)
        kwd = None
        result = ""
        if keywords:
            absolute_kwds = reduce_keywords(keywords)
            kwd = list(used.intersection(absolute_kwds))
            # if keywords == ['~ppc64']:
            # print "Checked keywords for kwd", keywords, used, "kwd =", kwd
        if not kwd:
            # print "Checking for kwd against portage.archlist"
            absolute_kwds = reduce_keywords(keywords)
            # check for one against archlist then re-check
            kwd = list(absolute_kwds.intersection(portage.archlist))
            # print "determined keyword =", kwd
        if len(kwd) == 1:
            key = kwd[0]
            # print "determined keyword =", key
        elif not kwd:
            # print "kwd != 1", kwd, cpv
            result = self._missing(self.keyword, keywords)
        else:  # too many, try to narrow them dowm
            # print "too many kwd's, trying to match against arch"
            _kwd = list(set(kwd).intersection(self.arch))
            key = ""
            if _kwd:
                # print "found one! :)", _kwd
                key = _kwd
            else:  # try re-running the short list against archlist
                # print "Checking kwd for _kwd against portage.archlist"
                _kwd = list(set(kwd).intersection(portage.archlist))
                if _kwd and len(_kwd) == 1:
                    # print "found one! :)", _kwd
                    key = _kwd[0]
                else:
                    # print " :( didn't work, _kwd =", _kwd, "giving up on:", cpv
                    result = self._missing(self.keyword, keywords)
        i = 0
        while not result and i in self.parse_range:
            parsekey = self.parse_order[i]
            result = self.check_key[parsekey](key, keywords)
            i += 1
        return result

    def _stable(self, key, keywords):
        """test for a normal stable keyword"""
        if key in keywords:
            return key
        return ""

    def _testing(self, key, keywords):
        """test for a normal testing keyword"""
        if ("~" + key) in keywords:
            return "~" + key
        return ""

    def _prefix(self, key, keywords):
        """test for a stable prefix keyword"""
        if not self.prefix:
            return ""
        _key = "-".join([key, self.prefix])
        if _key in keywords:
            # print key, "is in", keywords
            return _key
        return ""

    def _testing_prefix(self, key, keywords):
        """test for a testing prefix keyword"""
        if not self.prefix:
            return ""
        _key = "~" + "-".join([key, self.prefix])
        if _key in keywords:
            # print key, "is in", keywords
            return _key
        return ""

    def _missing(self, key, keywords):
        """generates a missing keyword to return"""
        if self.prefix and key != self.keyword:
            _key = "-".join([key, self.prefix])
        else:
            _key = "-" + key
        # print "_missisng :(  _key =", _key
        return _key

    def get_inst_keyword_cpv(self, cpv):
        """Determines the installed with keyword for cpv

        @type cpv: string
        @param cpv: an installed CAT/PKG-VER
        @rtype: string
        @returns a keyword determined to have been used to install cpv
        """
        keywords, used = self.vardb.aux_get(cpv, ["KEYWORDS", "USE"])
        keywords = keywords.split()
        used = used.split()
        return self._parse(keywords, used, cpv=cpv)

    def get_inst_keyword_pkg(self, pkg):
        """Determines the installed with keyword for cpv

        @param pkg: gentoolkit.package.Package object
        @rtype: string
        @returns a keyword determined to have been used to install cpv
        """
        keywords, used = pkg.environment(
            ["KEYWORDS", "USE"], prefer_vdb=True, fallback=False
        )
        keywords = keywords.split()
        used = used.split()
        return self._parse(keywords, used, pkg=pkg)

    def _parse(self, keywords, used, pkg=None, cpv=None):
        if pkg:
            _cpv = pkg.cpv
        else:
            _cpv = cpv
        if not self.parse_order:
            self.set_order(used)
        keyword = self.keyword
        # sanity check
        if self.arch not in used:
            # print "Found a mismatch = ", cpv, self.arch, used
            self.mismatched.append(_cpv)
        if keyword in keywords:
            # print "keyword", keyword, "is in", keywords
            return keyword
        elif "~" + keyword in keywords:
            # print "~keyword", keyword, "is in", keywords
            return "~" + keyword
        else:
            keyword = self.determine_keyword(keywords, used, _cpv)
            if not keyword:
                raise errors.GentoolkitUnknownKeyword(_cpv, " ".join(keywords), used)
            return keyword

    def set_order(self, used):
        """Used to set the parsing order to determine a keyword
        used for installation.

        This is needed due to the way prefix arch's and keywords
        work with portage.  It looks for the 'prefix' flag. A positive result
        sets it to the prefix order and keyword.

        @type used: list
        @param used: a list of pkg USE flags or the system USE flags"""
        if "prefix" in used:
            # print "SET_ORDER() Setting parse order to prefix"
            prefix = None
            self.parse_order = self.prefix_order
            for key in self.accept_keywords:
                # print "SET_ORDER()  '"+key+"'"
                if "-" in key:
                    # print "SET_ORDER()found prefix keyword :", key
                    if self.arch in key:
                        prefix = key.split("-")[1]
                        # print "prefix =", prefix
                        self.prefix = prefix
            self.keyword = "-".join([self.arch, prefix])
        else:
            # print "SET_ORDER() Setting parse order to normal"
            self.parse_order = self.normal_order
            self.keyword = self.arch
        # print "SET_ORDER() completed: prefix =", self.prefix, ", keyword =", \
        #   self.keyword, "parse order =",self.parse_order
        # print