path: root/portato/backend/portage/system.py

# -*- coding: utf-8 -*-
#
# File: portato/backend/portage/system.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2006-2008 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>

from __future__ import absolute_import, with_statement

import re, os, os.path
import portage
from collections import defaultdict

from .package import PortagePackage
from .settings import PortageSettings
from ..system_interface import SystemInterface
from ...helper import debug, info, warning, unique_array

class PortageSystem (SystemInterface):
	"""This class provides access to the portage-system."""

	# pre-compile the RE removing the ".svn" and "CVS" entries
	unwantedPkgsRE = re.compile(r".*(\.svn|CVS)$")
	withBdepsRE = re.compile(r"--with-bdeps\s*( |=)\s*y")

	def __init__ (self):
		"""Constructor."""
		self.settings = PortageSettings()
		portage.WORLD_FILE = os.path.join(self.settings.settings["ROOT"],portage.WORLD_FILE)

		self.use_descs = {}
		self.local_use_descs = defaultdict(dict)

		self._version = tuple([x.split("_")[0] for x in portage.VERSION.split(".")])

	def get_version (self):
		return "Portage %s" % portage.VERSION
	
	def new_package (self, cpv):
		return PortagePackage(cpv)

	def get_config_path (self):
		return portage.USER_CONFIG_PATH

	def get_merge_command (self):
		return ["/usr/bin/python", "/usr/bin/emerge"]

	def get_sync_command (self):
		return self.get_merge_command()+["--sync"]

	def get_oneshot_option (self):
		return ["--oneshot"]

	def get_newuse_option (self):
		return ["--newuse"]

	def get_deep_option (self):
		return ["--deep"]

	def get_update_option (self):
		return ["--update"]

	def get_pretend_option (self):
		return ["--pretend", "--verbose"]

	def get_unmerge_option (self):
		return ["--unmerge"]

	def get_environment (self):
		default_opts = self.get_global_settings("EMERGE_DEFAULT_OPTS")
		opts = dict(os.environ)
		opts.update(TERM = "xterm") # emulate terminal :)
		opts.update(PAGER = "less") # force less

		if default_opts:
			opt_list = default_opts.split()
			changed = False

			for option in ["--ask", "-a", "--pretend", "-p"]:
				if option in opt_list:
					opt_list.remove(option)
					changed = True
			
			if changed:
				opts.update(EMERGE_DEFAULT_OPTS = " ".join(opt_list))

		return opts

	def cpv_matches (self, cpv, criterion):
		if portage.match_from_list(criterion, [cpv]) == []:
			return False
		else:
			return True

	def with_bdeps(self):
		"""Returns whether the "--with-bdeps" option is set to true.

		@returns: the value of --with-bdeps
		@rtype: boolean
		"""

		settings = self.get_global_settings("EMERGE_DEFAULT_OPTS").split()
		for s in settings:
			if self.withBdepsRE.match(s):
				return True

		return False

	def find_lambda (self, name):
		"""Returns the function needed by all the find_all_*-functions. Returns None if no name is given.
		
		@param name: name to build the function of
		@type name: string or RE
		@returns: 
					1. None if no name is given
					2. a lambda function
		@rtype: function
		"""
		
		if name != None:
			if isinstance(name, str):
				return lambda x: re.match(".*"+name+".*",x, re.I)
			else: # assume regular expression
				return lambda x: name.match(x)
		else:
			return lambda x: True

	def geneticize_list (self, list_of_packages, only_cpv = False):
		"""Convertes a list of cpv's into L{backend.Package}s.
		
		@param list_of_packages: the list of packages
		@type list_of_packages: string[]
		@param only_cpv: do nothing - return the passed list
		@type only_cpv: boolean
		@returns: converted list
		@rtype: PortagePackage[]
		"""
		
		if not only_cpv:
			return [PortagePackage(x) for x in list_of_packages]
		else:
			return list_of_packages

	def get_global_settings (self, key):
		self.settings.settings.reset()
		return self.settings.settings[key]

	def find_best (self, list, only_cpv = False):
		if only_cpv:
			return portage.best(list)
		else:
			return PortagePackage(portage.best(list))

	def find_best_match (self, search_key, masked = False, only_installed = False, only_cpv = False):
		t = []
		
		if not only_installed:
			pkgSet = "tree"
		else:
			pkgSet = "installed"

		t = self.find_packages(search_key, pkgSet = pkgSet, masked = masked, with_version = True, only_cpv = True)
		
		if self._version >= (2,1,5):
			t += [pkg.get_cpv() for pkg in self.find_packages(search_key, "installed") if not (pkg.is_testing(True) or pkg.is_masked())]
		else:
			t = self.find_packages(search_key, "installed", only_cpv=True)

		if t:
			t = unique_array(t)
			return self.find_best(t, only_cpv)

		return None

	def find_packages (self, key = "", pkgSet = "all", masked = False, with_version = True, only_cpv = False):
		if key is None: key = ""
		
		is_regexp = key == "" or ("*" in key and key[0] not in ("*","=","<",">","~","!"))
		
		def installed(key):
			if is_regexp:
				if with_version:
					t = self.settings.vartree.dbapi.cpv_all()
				else:
					t = self.settings.vartree.dbapi.cp_all()

				if key:
					t = filter(lambda x: re.match(key, x, re.I), t)

				return t
			else:	
				return self.settings.vartree.dbapi.match(key)

		def tree(key):
			if is_regexp:
				if with_version:
					t = self.settings.porttree.dbapi.cpv_all()
				else:
					t = self.settings.porttree.dbapi.cp_all()

				if key:
					t = filter(lambda x: re.match(key, x, re.I), t)
			
			elif masked:	
				t = self.settings.porttree.dbapi.xmatch("match-all", key)
			else:
				t = self.settings.porttree.dbapi.match(key)
			
			return t
		
		def all(key):
			return unique_array(installed(key)+tree(key))

		def uninstalled (key):
			alist = set(all(key))
			inst = set(installed(key))
			return list(alist - inst)

		def _ws (key, crit, pkglist):
			pkgs = self.__find_resolved_unresolved(pkglist, crit, only_cpv = with_version)[0]
			if not with_version:
				pkgs = [x.get_cp(x) for x in list]

			if is_regexp:
				return filter(lambda x: re.match(key, x, re.I), pkgs)
			
			return pkgs

		def world (key):
			with open(portage.WORLD_FILE) as f:
				pkglist = f.readlines()

			return _ws(key, lambda cpv: cpv[0] != "#", pkglist)

		def system (key):
			return _ws(key, lambda cpv: cpv[0] == "*", self.settings.settings.packages)

		funcmap = {
				"all" : all,
				"installed" : installed,
				"uninstalled" : uninstalled,
				"world" : world,
				"system" : system,
				"tree" : tree
				}

		pkgSet = pkgSet.lower()
		if pkgSet == "": pkgSet = "all"

		func = funcmap[pkgSet]
		
		try:
			t = func(key)
		# catch the "ambigous package" Exception
		except ValueError, e:
			if isinstance(e[0], list):
				t = []
				for cp in e[0]:
					t += func(cp)
			else:
				raise

		# Make the list of packages unique
		t = unique_array(t)
		t.sort()

		return self.geneticize_list(t, only_cpv or not with_version)

	def __find_resolved_unresolved (self, list, check, only_cpv = False):
		"""Checks a given list and divides it into a "resolved" and an "unresolved" part.

		@param list: list of cpv's
		@type list: string[]
		@param check: function called to check whether an entry is ok
		@type check: function(cpv)
		@param only_cpv: do not return packages but cpv-strings
		@type only_cpv: boolean

		@returns: the divided list: (resolved, unresolved)
		@rtype: (Package[], Package[]) or (string[], string[])"""
		resolved = []
		unresolved = []
		for x in list:
			cpv = x.strip()
			if len(cpv) and check(cpv):
				pkg = self.find_best_match(cpv, only_cpv = only_cpv)
				if pkg:
					resolved.append(pkg)
				else:
					unresolved.append(self.find_best_match(cpv, True, only_cpv = <