from portage.exception import InvalidData, InvalidAtom
from portage.localization import _
from portage.versions import catpkgsplit, catsplit, \
- pkgcmp, pkgsplit, ververify, _cat, _pkg, _cp, _cpv
+ pkgcmp, pkgsplit, ververify, _cp, _cpv
import portage.cache.mappings
if sys.hexversion >= 0x3000000:
blocker = False
self.__dict__['blocker'] = blocker
m = _atom_re.match(s)
+ extended_syntax = False
if m is None:
if allow_wildcard:
m = _atom_wildcard_re.match(s)
if m is None:
raise InvalidAtom(self)
op = None
- cpv = cp = m.groupdict()['simple']
- slot = None
+ gdict = m.groupdict()
+ cpv = cp = gdict['simple']
+ if cpv.find("**") != -1:
+ raise InvalidAtom(self)
+ slot = gdict['slot']
use_str = None
+ extended_syntax = True
else:
raise InvalidAtom(self)
elif m.group('op') is not None:
self.__dict__['cpv'] = cpv
self.__dict__['slot'] = slot
self.__dict__['operator'] = op
+ self.__dict__['extended_syntax'] = extended_syntax
if use_str is not None:
use = _use_dep(dep_getusedeps(s))
memo[id(self)] = self
return self
+def extended_cp_match(extended_atom, other):
+ """
+ Checks if an extended syntax atom matches the other, non extended atom
+ """
+ my_slot = dep_getslot(extended_atom)
+ if my_slot is not None:
+ extended_atom = extended_atom[:-(len(my_slot)+1)]
+ mysplit = catsplit(extended_atom)
+ my_cat = mysplit[0]
+ my_pkg = mysplit[1]
+
+ other_slot = dep_getslot(other)
+ if other_slot is not None:
+ other = other[:-(len(other_slot)+1)]
+ othersplit = catsplit(other)
+ other_cat = othersplit[0]
+ other_pkg = othersplit[1]
+
+ if my_slot is not None and other_slot is not None and \
+ my_slot != other_slot:
+ return False
+
+ for my_val, other_val in ((my_cat, other_cat), (my_pkg, other_pkg)):
+ if my_val == "*":
+ continue
+
+ start = 0
+ parts = my_val.split("*")
+ for id, part in enumerate(parts):
+ if not part:
+ if id == len(parts)-1:
+ start = len(other_val)
+ continue
+ start = other_val.find(part, start)
+ if start == -1:
+ return False
+
+ start += len(part)
+
+ if start != len(other_val):
+ return False
+
+ return True
+
+class ExtendedAtomDict(object):
+ """
+ dict() wrapper that supports extended atoms as keys and allows lookup
+ of a normal cp against other normal cp and extended cp.
+ The value type has to be given to __init__ and is assumed to be the same
+ for all values.
+ """
+ def __init__(self, value_class):
+ self._extended = {}
+ self._normal = {}
+ self._value_class = value_class
+
+ def setdefault(self, cp, default=None):
+ if "*" in cp:
+ return self._extended.setdefault(cp, default)
+ else:
+ return self._normal.setdefault(cp, default)
+
+ def get(self, cp):
+ ret = self._value_class()
+ normal_match = self._normal.get(cp)
+ if normal_match is not None:
+ if hasattr(ret, "update"):
+ ret.update(normal_match)
+ elif hasattr(ret, "extend"):
+ ret.extend(normal_match)
+ else:
+ raise NotImplementedError()
+
+ for extended_cp in self._extended:
+ if extended_cp_match(extended_cp, cp):
+ if hasattr(ret, "update"):
+ ret.update(self._extended[extended_cp])
+ elif hasattr(ret, "extend"):
+ ret.extend(self._extended[extended_cp])
+ else:
+ raise NotImplementedError()
+
+ return ret
+
+ def __setitem__(self, cp, val):
+ if "*" in cp:
+ self._extended[cp] = val
+ else:
+ self._normal[cp] = val
+
+ def __getitem__(self, cp):
+ if "*" in cp:
+ return self._extended[cp]
+ else:
+ return self._normal[cp]
+
+ def clear(self):
+ self._extended.clear()
+ self._normal.clear()
+
+
def get_operator(mydep):
"""
Return the operator used in a depstring.
'(?P<op>' + _op + _cpv + ')|' +
'(?P<star>=' + _cpv + r'\*)|' +
'(?P<simple>' + _cp + '))(:' + _slot + ')?)(' + _use + ')?$', re.VERBOSE)
-_atom_wildcard_re = re.compile('(?P<simple>((' + _cat + '|\*)/(' + _pkg + '|\*)))$')
+
+_extended_cat = r'[\w+*][\w+.*-]*'
+_extended_pkg = r'[\w+*][\w+*-]*?'
+
+_atom_wildcard_re = re.compile('(?P<simple>(' + _extended_cat + ')/(' + _extended_pkg + '))(:(?P<slot>' + _slot + '))?$')
def isvalidatom(atom, allow_blockers=False, allow_wildcard=False):
"""
- >=cpv 2
- <=cpv 2
- cp 1
- - */p 0
- - c/* 0
- - */* -1
+ - cp:slot with extended syntax 0
+ - cp with extended syntax -1
"""
operator_values = {'=':6, '~':5, '=*':4,
'>':2, '<':2, '>=':2, '<=':2, None:1}
maxvalue = -2
bestm = None
for x in match_to_list(mypkg, mylist):
+ if x.extended_syntax:
+ if dep_getslot(x) is not None:
+ if maxvalue < 0:
+ maxvalue = 0
+ bestm = x
+ else:
+ if maxvalue < -1:
+ maxvalue = -1
+ bestm = x
+ continue
if dep_getslot(x) is not None:
if maxvalue < 3:
maxvalue = 3
bestm = x
op_val = operator_values[x.operator]
- if x.operator is None:
- c, p = catsplit(x)
- if c == "*":
- if p == "*":
- op_val = -1
- else:
- op_val = 0
- elif p == "*":
- op_val = 0
-
if op_val > maxvalue:
maxvalue = op_val
bestm = x
if cp is None:
mysplit = catpkgsplit(remove_slot(x))
if mysplit is not None:
- c = mysplit[0]
- p = mysplit[1]
- else:
- continue
- else:
- mysplit = catsplit(cp)
- c = mysplit[0]
- p = mysplit[1]
+ cp = mysplit[0] + '/' + mysplit[1]
+
+ if cp is None:
+ continue
- if cat in (c, "*") and pkg in (p, "*"):
+ if cp == mycpv or (mydep.extended_syntax and \
+ extended_cp_match(mycpv, cp)):
mylist.append(x)
-
elif operator == "=": # Exact match
for x in candidate_list:
else:
raise KeyError(_("Unknown operator: %s") % mydep)
- if slot is not None:
+ if slot is not None and not mydep.extended_syntax:
candidate_list = mylist
mylist = []
for x in candidate_list:
self["EROOT"] = target_root
self.backup_changes("EROOT")
- self.pusedict = {}
- self.pkeywordsdict = {}
- self._plicensedict = {}
- self._ppropertiesdict = {}
- self.punmaskdict = {}
+ self.pusedict = portage.dep.ExtendedAtomDict(dict)
+ self.pkeywordsdict = portage.dep.ExtendedAtomDict(dict)
+ self._plicensedict = portage.dep.ExtendedAtomDict(dict)
+ self._ppropertiesdict = portage.dep.ExtendedAtomDict(dict)
+ self.punmaskdict = portage.dep.ExtendedAtomDict(list)
abs_user_config = os.path.join(config_root, USER_CONFIG_PATH)
# locations for "categories" and "arch.list" files
pkgmasklines = stack_lists(pkgmasklines, incremental=1)
pkgunmasklines = stack_lists(pkgunmasklines, incremental=1)
- self.pmaskdict = {}
+ self.pmaskdict = portage.dep.ExtendedAtomDict(list)
for x in pkgmasklines:
self.pmaskdict.setdefault(x.cp, []).append(x)
has_changed = True
oldpuse = self.puse
self.puse = ""
- cpdict = {}
- cpdict.update(self.pusedict.get("*/*", {}))
- cpdict.update(self.pusedict.get(cat+"/*", {}))
- cpdict.update(self.pusedict.get("*/"+cp.split("/")[1], {}))
- cpdict.update(self.pusedict.get(cp, {}))
+ cpdict = self.pusedict.get(cp)
if cpdict:
keys = list(cpdict)
while keys:
"""
cp = cpv_getkey(cpv)
- c, p = catsplit(cp)
- mask_atoms = []
- mask_atoms.extend(self.pmaskdict.get("*/*", []))
- mask_atoms.extend(self.pmaskdict.get(c+"/*", []))
- mask_atoms.extend(self.pmaskdict.get("*/"+p, []))
- mask_atoms.extend(self.pmaskdict.get(cp, []))
+ mask_atoms = self.pmaskdict.get(cp)
if mask_atoms:
pkg_list = ["%s:%s" % (cpv, metadata["SLOT"])]
- unmask_atoms = []
- unmask_atoms.extend(self.punmaskdict.get("*/*", []))
- unmask_atoms.extend(self.punmaskdict.get(c+"/*", []))
- unmask_atoms.extend(self.punmaskdict.get("*/"+p, []))
- unmask_atoms.extend(self.punmaskdict.get(cp, []))
+ unmask_atoms = self.punmaskdict.get(cp)
for x in mask_atoms:
if not match_from_list(x, pkg_list):
continue
"""
accept_license = self._accept_license
cp = cpv_getkey(cpv)
- c, p = catsplit(cp)
- cpdict = {}
- cpdict.update(self._plicensedict.get("*/*", {}))
- cpdict.update(self._plicensedict.get(c+"/*", {}))
- cpdict.update(self._plicensedict.get("*/"+p, {}))
- cpdict.update(self._plicensedict.get(cp, {}))
+ cpdict = self._plicensedict.get(cp)
if cpdict:
accept_license = list(self._accept_license)
cpv_slot = "%s:%s" % (cpv, metadata["SLOT"])
"""
accept_properties = self._accept_properties
cp = cpv_getkey(cpv)
- c, p = catsplit(cp)
- cpdict = {}
- cpdict.update(self._ppropertiesdict.get("*/*", {}))
- cpdict.update(self._ppropertiesdict.get(c+"/*", {}))
- cpdict.update(self._ppropertiesdict.get("*/"+p, {}))
- cpdict.update(self._ppropertiesdict.get(cp, {}))
+ cpdict = self._ppropertiesdict.get(cp)
if cpdict:
accept_properties = list(self._accept_properties)
cpv_slot = "%s:%s" % (cpv, metadata["SLOT"])
# Distributed under the terms of the GNU General Public License v2
import sys
-from portage.dep import Atom, best_match_to_list, match_from_list
+from portage.dep import Atom, ExtendedAtomDict, best_match_to_list, match_from_list
from portage.exception import InvalidAtom
from portage.versions import catsplit, cpv_getkey
def __init__(self):
self._atoms = set()
- self._atommap = {}
+ self._atommap = ExtendedAtomDict(set)
self._loaded = False
self._loading = False
self.errors = []
"""
cpv_slot_list = [pkg]
cp = cpv_getkey(pkg.cpv)
- c, p = catsplit(cp)
self._load() # make sure the atoms are loaded
- atoms = set()
- atoms.update(self._atommap.get("*/*", set()))
- atoms.update(self._atommap.get(c+"/*", set()))
- atoms.update(self._atommap.get("*/"+p, set()))
- atoms.update(self._atommap.get(cp, set()))
-
+ atoms = self._atommap.get(cp)
if atoms:
for atom in atoms:
if match_from_list(atom, cpv_slot_list):
( "sys-apps/*",
(None, 'sys-apps/*', None, None, None), True ),
( "*/portage",
- (None, '*/portage', None, None, None), True )
+ (None, '*/portage', None, None, None), True ),
+ ( "s*s-*/portage:1",
+ (None, 's*s-*/portage', None, '1', None), True ),
+ ( "*/po*ge:2",
+ (None, '*/po*ge', None, '2', None), True ),
]
tests_xfail = [
--- /dev/null
+# test_isvalidatom.py -- Portage Unit Testing Functionality
+# Copyright 2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+
+from portage.tests import TestCase
+from portage.dep import ExtendedAtomDict
+
+class TestExtendedAtomDict(TestCase):
+
+ def testExtendedAtomDict(self):
+ d = ExtendedAtomDict(dict)
+ d["*/*"] = { "test1": "x" }
+ d["dev-libs/*"] = { "test2": "y" }
+ d.setdefault("sys-apps/portage", {})["test3"] = "z"
+ self.assertEqual(d.get("dev-libs/A"), { "test1": "x", "test2": "y" })
+ self.assertEqual(d.get("sys-apps/portage"), { "test1": "x", "test3": "z" })
+ self.assertEqual(d["dev-libs/*"], { "test2": "y" })
+ self.assertEqual(d["sys-apps/portage"], { "test3": "z" })
[Atom("=dev-libs/A-1:0")]),
("dev-libs/A-1", [Atom("dev-libs/*", allow_wildcard=True), Atom("=dev-libs/A-1:0")], \
[Atom("=dev-libs/A-1:0"), Atom("dev-libs/*", allow_wildcard=True)]),
- ("dev-libs/A-1", [Atom("*/*", allow_wildcard=True), Atom("dev-libs/*", allow_wildcard=True), \
+ ("dev-libs/A-1:0", [Atom("dev-*/*", allow_wildcard=True), Atom("dev-*/*:0", allow_wildcard=True),\
Atom("dev-libs/A"), Atom("<=dev-libs/A-2"), Atom("dev-libs/A:0"), \
Atom("=dev-libs/A-1*"), Atom("~dev-libs/A-1"), Atom("=dev-libs/A-1")], \
[Atom("=dev-libs/A-1"), Atom("~dev-libs/A-1"), Atom("=dev-libs/A-1*"), \
Atom("dev-libs/A:0"), Atom("<=dev-libs/A-2"), Atom("dev-libs/A"), \
- Atom("dev-libs/*", allow_wildcard=True), Atom("*/*", allow_wildcard=True)])
+ Atom("dev-*/*:0", allow_wildcard=True), Atom("dev-*/*", allow_wildcard=True)])
]
for pkg, atom_list, result in tests:
projects / portage.git / commitdiff