path: root/portato/backend/flags.py

# -*- coding: utf-8 -*-
#
# File: portato/backend/flags.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2006-2010 René 'Necoro' Neumann
# This is free software.  You may redistribute copies of it under the terms of
# the GNU General Public License version 2.
# There is NO WARRANTY, to the extent permitted by law.
#
# Written by René 'Necoro' Neumann <necoro@necoro.net>

import os
import itertools as itt
from subprocess import Popen, PIPE # needed for grep

from . import system, is_package
from ..helper import debug, error, warning

CONFIG = {
        "usefile" : "portato",
        "maskfile" : "portato",
        "testingfile" : "portato",
        "usePerVersion" : True,
        "maskPerVersion" : True,
        "testingPerVersion" : True
        }

class Constants:

    def __init__ (self):
        self.clear()
    
    def clear (self):
        self._use_path = None
        self._mask_path = None
        self._unmask_path = None
        self._testing_path = None
        self._use_path_is_dir = None
        self._mask_path_is_dir = None
        self._unmask_path_is_dir = None
        self._testing_path_is_dir = None

    def __get (self, name, path):
        if self.__dict__[name] is None:
            self.__dict__[name] = os.path.join(system.get_config_path(), path)

        return self.__dict__[name]

    def __is_dir(self, path):
        name = "_" + path + "_is_dir"
        if self.__dict__[name] is None:
            self.__dict__[name] = os.path.isdir(self.__class__.__dict__[path](self))
        return self.__dict__[name]
    
    def use_path (self):
        return self.__get("_use_path", "package.use")

    def use_path_is_dir (self):
        return self.__is_dir("use_path")

    def mask_path (self):
        return self.__get("_mask_path", "package.mask")

    def mask_path_is_dir (self):
        return self.__is_dir("mask_path")

    def unmask_path (self):
        return self.__get("_unmask_path", "package.unmask")

    def unmask_path_is_dir (self):
        return self.__is_dir("unmask_path")

    def testing_path (self):
        return self.__get("_testing_path", "package.keywords")

    def testing_path_is_dir (self):
        return self.__is_dir("testing_path")

CONST = Constants()

### GENERAL PART ###

def grep (pkg, path):
    """Grep runs "egrep" on a given path and looks for occurences of a given package.
    @param pkg: the package
    @type pkg: string (cpv) or L{backend.Package}-object
    @param path: path to look in
    @type path: string
    
    @returns: occurences of pkg in the format: "file:line-no:complete_line_found"
    @rtype: string"""

    if not is_package(pkg):
        pkg = system.new_package(pkg) # assume it is a cpv or a gentoolkit.Package

    if os.path.exists(path):
        command = "egrep -x -n -r -H '^[<>!=~]{0,2}%s(-[0-9].*)?[[:space:]]?.*$' %s" # %s is replaced in the next line ;)
        return Popen((command % (pkg.get_cp(), path)), shell = True, stdout = PIPE).communicate()[0].splitlines()
    else:
        return []

def get_data(pkg, path):
    """This splits up the data of L{grep} and builds tuples in the format (file,line,criterion,list_of_flags).
    @param pkg: package to find
    @type pkg: string (cpv) or L{backend.Package}-object
    @param path: path to look in
    @type path: string
    
    @returns: a list of tuples in the form (file,line,criterion,list_of_flags)
    @rtype: (string,string,string,string[])[]"""
    
    flags = []

    for line in grep(pkg, path):
        file, line, fl = line.split(":", 2) # get file, line and flag-list
        fl = fl.split()
        crit = fl[0]
        fl = fl[1:]
        
        # stop after first comment
        nc = itt.takewhile(lambda x: x[0] != "#", fl)
        flags.append((file, line, crit, list(nc)))

    return flags

def set_config (cfg):
    """This function sets the CONFIG-variable for the whole module. Use this instead of modifying L{CONFIG} directly.
    @param cfg: a dictionary with at least all the keys of the CONFIG-var
    @type cfg: dict
    @raises KeyError: if a keyword is missing in the new cfg"""

    for i in CONFIG.keys():
        if not i in cfg:
            raise KeyError("Missing keyword in config: "+i)

    for i in CONFIG:
        CONFIG[i] = cfg[i]

def generate_path (cpv, exp):
    """Generates the correct path out of given wildcards. 
    These wildcards can be:
        - $(cat) : category
        - $(cat-1): first part of the category (e.g. "app")
        - $(cat-2): second part of the category
        - $(pkg) : name of the package
        - $(version) : version of the package
    
    @param cpv: the cpv of the current package
    @type cpv: string (cat/pkg-ver)
    @param exp: the expression to render the path from
    @type exp: string
    @returns: rendered path
    @rtype string"""

    if exp.find("$(") != -1:
        cat, pkg, ver, rev = system.split_cpv(cpv)
        if rev != "r0":
            ver = "%s-%s" % (ver, rev)
        exp = exp.replace("$(cat)",cat).\
                replace("$(pkg)",pkg).\
                replace("$(cat-1)",cat.split("-")[0]).\
                replace("$(cat-2)",cat.split("-")[1]).\
                replace("$(version)",ver)
    return exp

### USE FLAG PART ###
useFlags = {} # useFlags in the file
newUseFlags = {} # useFlags as we want them to be: format: cpv -> [(file, line, useflag, (true if removed from list / false if added))]

def invert_use_flag (flag):
    """Invertes a flag.

        >>> invert_use_flag("foo")
        -foo
        >>> invert_use_flag("-bar")
        bar

    @param flag: the flag
    @type flag: string
    @returns: inverted flag
    @rtype: string
    """
    
    if flag[0] == "-":
        return flag[1:]
    else:
        return "-"+flag

def sort_use_flag_list (flaglist):
    """
    Sorts a list of useflags. If a use flag starts with "+" or "-" this one is ignored for the matter of sorting.
    This functions sorts the list itself - thus does not create a new one. But for convenience it returns the list too.

    @param flaglist: the list of useflags
    @type flaglist: string[]

    @returns: the sorted list (Note: it is the same as the one passed in)
    @rtype: string[]
    """
    
    def flag_key (flag):
        if flag[0] in "+-":
            return flag[1:]
        else:
            return flag
    
    flaglist.sort(key = flag_key)
    return flaglist

def filter_defaults (flaglist):
    """
    Removes "+" and "-" from IUSE defaults.

    @param flaglist: the list of useflags
    @type flaglist: string<iterator>

    @returns: the "cleaned" list
    @rtype: string<iterator>
    """

    for flag in flaglist:
        if flag[0] in "+-":
            yield flag[1:]
        else:
            yield flag

def set_use_flag (pkg, flag):
    """Sets the useflag for a given package.
    
    @param pkg: the package
    @type pkg: string (cpv) or L{backend.Package}-object
    @param flag: the flag to set
    @type flag: string"""

    global useFlags, newUseFlags

    if not is_package(pkg):
        pkg = system.new_package(pkg) # assume cpv or gentoolkit.Package

    cpv = pkg.get_cpv()
    invFlag = invert_use_flag(flag)
    
    # if not saved in useFlags, get it by calling get_data() which calls grep()
    data = None
    if not cpv in useFlags:
        data = get_data(pkg, CONST.use_path())
        useFlags[cpv] = data
    else:
        data = useFlags[cpv]

    if not cpv in newUseFlags:
        newUseFlags[cpv] = []

    debug("data: %s", str(data))
    # add a useflag / delete one
    added = False
    for file, line, crit, flags in data:
        if pkg.matches(crit):
            # we have the inverted flag in the uselist/newuselist --> delete it
            if invFlag in flags or (file, line, invFlag, False) in newUseFlags[cpv] or (file, line, flag, True) in newUseFlags[cpv]:
                if added: del newUseFlags[cpv][-1] # we currently added it as an extra option - delete it
                added = True
                jumpOut = False
                for t in ((file, line, invFlag, False),(file, line, flag, True)):
                    if t in newUseFlags[cpv]:
                        newUseFlags[cpv].remove(t)
                        jumpOut = True
                        # break # don't break as both cases can be valid (see below)