def make_keywords_filter(self, arch, default_keys, accept_keywords,
profile_keywords, incremental=False):
"""Generates a restrict that matches iff the keywords are allowed."""
if not accept_keywords and not profile_keywords:
return packages.PackageRestriction(
"keywords", values.ContainmentMatch(*default_keys))
if "~" + arch.lstrip("~") not in default_keys:
# stable; thus empty entries == ~arch
unstable = "~" + arch
def f(r, v):
if not v:
return r, unstable
return r, v
data = collapsed_restrict_to_data(
((packages.AlwaysTrue, default_keys),),
(f(*i) for i in accept_keywords))
else:
if incremental:
f = collapsed_restrict_to_data
else:
f = non_incremental_collapsed_restrict_to_data
data = f(((packages.AlwaysTrue, default_keys),), accept_keywords)
if incremental:
raise NotImplementedError(self.incremental_apply_keywords_filter)
#f = self.incremental_apply_keywords_filter
else:
f = self.apply_keywords_filter
return delegate(partial(f, data, profile_keywords))
def _make_keywords_filter(self, default_keys, accept_keywords, incremental=False):
"""Generates a restrict that matches iff the keywords are allowed."""
if not accept_keywords and not self.profile.keywords:
return packages.PackageRestriction(
"keywords", values.ContainmentMatch2(frozenset(default_keys)))
if self.unstable_arch not in default_keys:
# stable; thus empty entries == ~arch
def f(r, v):
if not v:
return r, self.unstable_arch
return r, v
data = collapsed_restrict_to_data(
((packages.AlwaysTrue, default_keys),),
(f(*i) for i in accept_keywords))
else:
if incremental:
f = collapsed_restrict_to_data
else:
f = non_incremental_collapsed_restrict_to_data
data = f(((packages.AlwaysTrue, default_keys),), accept_keywords)
if incremental:
raise NotImplementedError(self._incremental_apply_keywords_filter)
#f = self._incremental_apply_keywords_filter
else:
f = self._apply_keywords_filter
return delegate(partial(f, data))
def _vfilters(self, pkg_accept_keywords=None, pkg_keywords=None):
if pkg_accept_keywords is None:
pkg_accept_keywords = self.pkg_accept_keywords
if pkg_keywords is None:
pkg_keywords = self.pkg_keywords
# ~amd64 -> [amd64, ~amd64]
default_keywords = set([self.arch])
default_keywords.update(self.settings['ACCEPT_KEYWORDS'])
for x in self.settings['ACCEPT_KEYWORDS']:
if x.startswith("~"):
default_keywords.add(x.lstrip("~"))
# create keyword filters
accept_keywords = (
pkg_keywords + pkg_accept_keywords + self.profile.accept_keywords)
vfilters = [self._make_keywords_filter(
default_keywords, accept_keywords,
incremental="package.keywords" in const.incrementals)]
# add license filters
master_license = []
master_license.extend(self.settings.get('ACCEPT_LICENSE', ()))
if master_license or self.pkg_licenses:
# restrict that matches iff the licenses are allowed
restrict = delegate(partial(self._apply_license_filter, master_license))
vfilters.append(restrict)
return tuple(vfilters)
def make_mask_filter(masks, negate=False):
atoms = defaultdict(list)
globs = []
for m in masks:
if isinstance(m, _atom):
atoms[m.key].append(m)
else:
globs.append(m)
return delegate(partial(apply_mask_filter, globs, atoms), negate=negate)
def make_mask_filter(masks, negate=False):
atoms = defaultdict(list)
globs = []
for m in masks:
if isinstance(m, _atom):
atoms[m.key].append(m)
else:
globs.append(m)
return delegate(partial(apply_mask_filter, globs, atoms), negate=negate)
def make_license_filter(self, master_license, pkg_licenses):
"""Generates a restrict that matches iff the licenses are allowed."""
return delegate(partial(self.apply_license_filter, master_license, pkg_licenses))
def make_license_filter(self, master_license, pkg_licenses):
"""Generates a restrict that matches iff the licenses are allowed."""
return delegate(
partial(self.apply_license_filter, master_license, pkg_licenses))