"installed", "metadata", "onlydeps", "operation",
"root_config", "type_name",
"category", "counter", "cp", "cpv_split",
- "inherited", "iuse", "mtime",
+ "inherited", "invalid", "iuse", "mtime",
"pf", "pv_split", "root", "slot", "slot_atom",) + \
("_use",)
self.cpv_split = portage.catpkgsplit(self.cpv)
self.pv_split = self.cpv_split[1:]
+ def _invalid_metadata(self, msg):
+ if self.invalid is None:
+ self.invalid = []
+ self.invalid.append(msg)
+
class _use_class(object):
__slots__ = ("__weakref__", "enabled")
class _iuse(object):
- __slots__ = ("__weakref__", "all", "enabled", "disabled", "iuse_implicit", "regex", "tokens")
+ __slots__ = ("__weakref__", "all", "enabled", "disabled",
+ "iuse_implicit", "tokens") + \
+ ('_regex',)
def __init__(self, tokens, iuse_implicit):
self.tokens = tuple(tokens)
self.disabled = frozenset(disabled)
self.all = frozenset(chain(enabled, disabled, other))
- def __getattribute__(self, name):
- if name == "regex":
- try:
- return object.__getattribute__(self, "regex")
- except AttributeError:
- all = object.__getattribute__(self, "all")
- iuse_implicit = object.__getattribute__(self, "iuse_implicit")
- # Escape anything except ".*" which is supposed
- # to pass through from _get_implicit_iuse()
- regex = (re.escape(x) for x in chain(all, iuse_implicit))
- regex = "^(%s)$" % "|".join(regex)
- regex = regex.replace("\\.\\*", ".*")
- self.regex = re.compile(regex)
- return object.__getattribute__(self, name)
+ @property
+ def regex(self):
+ """
+ @returns: A regular expression that matches valid USE values which
+ may be specified in USE dependencies.
+ """
+ try:
+ return self._regex
+ except AttributeError:
+ # Escape anything except ".*" which is supposed
+ # to pass through from _get_implicit_iuse()
+ regex = (re.escape(x) for x in \
+ chain(self.all, self.iuse_implicit))
+ regex = "^(%s)$" % "|".join(regex)
+ regex = re.compile(regex.replace("\\.\\*", ".*"))
+ self._regex = regex
+ return regex
def _get_hash_key(self):
hash_key = getattr(self, "_hash_key", None)
__slots__ = ("_pkg",)
_wrapped_keys = frozenset(
["COUNTER", "INHERITED", "IUSE", "SLOT", "_mtime_"])
+ _use_conditional_keys = frozenset(
+ ['LICENSE', 'PROPERTIES', 'PROVIDE', 'RESTRICT',])
def __init__(self, pkg, metadata):
_PackageMetadataWrapperBase.__init__(self)
def __getitem__(self, k):
v = _PackageMetadataWrapperBase.__getitem__(self, k)
- if k in ('PROVIDE', 'LICENSE',):
+ if k in self._use_conditional_keys:
if '?' in v:
- v = paren_enclose(paren_normalize(use_reduce(
- paren_reduce(v), uselist=self._pkg.use.enabled)))
- self[k] = v
+ try:
+ v = paren_enclose(paren_normalize(use_reduce(
+ paren_reduce(v), uselist=self._pkg.use.enabled)))
+ except portage.exception.InvalidDependString:
+ # This error should already have been registered via
+ # self._pkg._invalid_metadata().
+ pass
+ else:
+ self[k] = v
elif k == 'USE' and not self._pkg.built:
if not v:
_PackageMetadataWrapperBase.__setitem__(self, k, v)
if k in self._wrapped_keys:
getattr(self, "_set_" + k.lower())(k, v)
+ elif k in self._use_conditional_keys:
+ try:
+ use_reduce(paren_reduce(v), matchall=1)
+ except portage.exception.InvalidDependString, e:
+ self._pkg._invalid_metadata("%s: %s" % (k, e))
def _set_inherited(self, k, v):
if isinstance(v, basestring):
except ValueError:
v = 0
self._pkg.mtime = v
+
+ @property
+ def properties(self):
+ return self['PROPERTIES'].split()
+
+ @property
+ def restrict(self):
+ return self['RESTRICT'].split()
else:
repo_path_real = portdb.getRepositoryPath(repo_name)
pkg_use = list(pkg.use.enabled)
- try:
- restrict = flatten(use_reduce(paren_reduce(
- pkg.metadata["RESTRICT"]), uselist=pkg_use))
- except portage.exception.InvalidDependString, e:
- if not pkg.installed:
- show_invalid_depstring_notice(x,
- pkg.metadata["RESTRICT"], str(e))
- del e
- return 1
- restrict = []
- if "ebuild" == pkg_type and x[3] != "nomerge" and \
- "fetch" in restrict:
+ if not pkg.built and pkg.operation == 'merge' and \
+ 'fetch' in pkg.metadata.restrict:
fetch = red("F")
if ordered:
counters.restrict_fetch += 1
else:
return colorize("PKG_NOMERGE", pkg_str)
- try:
- properties = flatten(use_reduce(paren_reduce(
- pkg.metadata["PROPERTIES"]), uselist=pkg.use.enabled))
- except portage.exception.InvalidDependString, e:
- if not pkg.installed:
- show_invalid_depstring_notice(pkg,
- pkg.metadata["PROPERTIES"], str(e))
- del e
- return 1
- properties = []
- interactive = "interactive" in properties
- if interactive and pkg.operation == "merge":
+ if 'interactive' in pkg.metadata.properties and \
+ pkg.operation == 'merge':
addl = colorize("WARN", "I") + addl[1:]
if ordered:
counters.interactive += 1
if not pkgsettings._accept_chost(pkg.cpv, pkg.metadata):
mreasons.append("CHOST: %s" % \
pkg.metadata["CHOST"])
+ if pkg.invalid:
+ for msg in pkg.invalid:
+ mreasons.append("invalid: %s" % (msg,))
if pkg.built and not pkg.installed:
if not "EPREFIX" in pkg.metadata or not pkg.metadata["EPREFIX"]:
self.uvlist = []
self._accept_chost_re = None
self._accept_license = None
+ self._accept_license_str = None
self.virtuals = {}
self.virts_p = {}
# ACCEPT_LICENSE is a lazily evaluated incremental, so that * can be
# used to match all licenses without every having to explicitly expand
# it to all licenses.
- if self._accept_license is None:
- if self.local_config:
- mysplit = []
- for curdb in mydbs:
- mysplit.extend(curdb.get('ACCEPT_LICENSE', '').split())
- if mysplit:
- self.configlist[-1]['ACCEPT_LICENSE'] = ' '.join(mysplit)
+ if self.local_config:
+ mysplit = []
+ for curdb in mydbs:
+ mysplit.extend(curdb.get('ACCEPT_LICENSE', '').split())
+ accept_license_str = ' '.join(mysplit)
+ if accept_license_str:
+ self.configlist[-1]['ACCEPT_LICENSE'] = accept_license_str
+ if accept_license_str != self._accept_license_str:
+ self._accept_license_str = accept_license_str
self._accept_license = tuple(self.expandLicenseTokens(mysplit))
- else:
- # repoman will accept any license
- self._accept_license = ()
+ else:
+ # repoman will accept any license
+ self._accept_license = ()
for mykey in myincrementals:
projects / portage.git / commitdiff