def _setup_restrictions(namespace, attr):
repo = namespace.domain.all_repos
target_restrictions = []
# If no targets are passed, create a restriction from the current working
# directory if inside a known repo.
cwd = os.getcwd()
if not namespace.targets and cwd in repo:
namespace.targets = [cwd]
for target in namespace.targets:
try:
target_restrictions.append(parserestrict.parse_match(target))
except parserestrict.ParseError as e:
if os.path.exists(target):
try:
restrict = repo.path_restrict(target)
# toss the repo restriction, keep the rest
target_restrictions.append(
boolean.AndRestriction(*restrict[1:]))
except ValueError as e:
argparser.error(e)
else:
argparser.error(e)
if target_restrictions:
namespace.restrict.append(boolean.OrRestriction(*target_restrictions))
if namespace.restrict:
namespace.restrict = boolean.AndRestriction(*namespace.restrict)
def transform_filters(args, kwargs): """ Transform our filters into pkgcore restrictions whenever possible. Takes args and kwargs as passed to .filter() and returns a tuple (restriction, newargs, newkwargs). If no filters can be transformed, None is returned as restriction, and args & kwargs are returned unmodified. """ newargs = [] f = [] for a in args: if isinstance(a, PkgCorePackage): a = str(a) if isinstance(a, str): a = PkgCoreAtom(a) if isinstance(a, PkgCoreAtom): f.append(a._r) else: newargs.append(a) if not f: f = None elif len(f) == 1: f = f[0] else: f = br.AndRestriction(*f) return (f, newargs, kwargs)
def test_dnf_solutions(self):
assert self.kls(true, true).dnf_solutions() == [[true], [true]]
assert (list(map(set, self.kls(
true, true,
boolean.AndRestriction(false, true)).dnf_solutions())) ==
list(map(set, [[true], [true], [false, true]])))
assert self.kls(self.kls(true, false), true).dnf_solutions() == [[true], [false], [true]]
assert self.kls().dnf_solutions() == [[]]
def test_cnf_solutions(self):
self.assertEqual(self.kls(true, true).cnf_solutions(), [[true, true]])
self.assertEqual([
set(x)
for x in self.kls(true, true, boolean.AndRestriction(
false, true)).cnf_solutions()
], [set(x) for x in [[true, false], [true, true]]])
self.assertEqual([
set(x) for x in self.kls(
self.kls(true, true, boolean.AndRestriction(
false, true))).cnf_solutions()
], [set(x) for x in [[true, false], [true, true]]])
self.assertEqual(
set(self.kls(self.kls(true, false), true).cnf_solutions()[0]),
set([true, false, true]))
self.assertEqual(self.kls().cnf_solutions(), [])
def test_cnf_solutions(self):
assert self.kls(true, true).cnf_solutions() == [[true, true]]
assert ([set(x) for x in self.kls(
true, true,
boolean.AndRestriction(false, true)).cnf_solutions()] ==
[set(x) for x in [[true, false], [true, true]]])
assert ([set(x) for x in self.kls(self.kls(
true, true,
boolean.AndRestriction(false, true))).cnf_solutions()] ==
[set(x) for x in [[true, false], [true, true]]])
assert (set(self.kls(
self.kls(true, false),
true).cnf_solutions()[0]) ==
set([true, false, true]))
assert self.kls().cnf_solutions() == []
def filter(self, *args, **kwargs):
r = self
filt, newargs, newkwargs = transform_filters(args, kwargs)
if filt:
r = PkgCoreFilteredRepo(self._repo,
br.AndRestriction(self._filt, filt))
if newargs or newkwargs:
r = PkgCoreFilteredPackageSet(r, args, kwargs)
return r
def test_dnf_solutions(self):
self.assertEqual(
self.kls(true, true).dnf_solutions(), [[true], [true]])
self.assertEqual(
map(
set,
self.kls(true, true,
boolean.AndRestriction(false, true)).dnf_solutions()),
map(set, [[true], [true], [false, true]]))
self.assertEqual(
self.kls(self.kls(true, false), true).dnf_solutions(),
[[true], [false], [true]])
self.assertEqual(self.kls().dnf_solutions(), [[]])
def evaluate_conditionals(self,
parent_cls,
parent_seq,
enabled,
tristate_locked=None):
if tristate_locked is not None:
assert len(self.restriction.vals) == 1
val = list(self.restriction.vals)[0]
if val in tristate_locked:
# if val is forced true, but the check is
# negation ignore it
# if !mips != mips
if (val in enabled) == self.restriction.negate:
return
elif not self.restriction.match(enabled):
return
if self.payload:
boolean.AndRestriction(*self.payload).evaluate_conditionals(
parent_cls, parent_seq, enabled, tristate_locked)
def test_identify_candidates(self):
with pytest.raises(TypeError):
self.repo.match("asdf")
rc = packages.PackageRestriction("category",
values.StrExactMatch("dev-util"))
assert \
sorted(set(x.package for x in self.repo.itermatch(rc))) == \
sorted(["diffball", "bsdiff"])
rp = packages.PackageRestriction("package",
values.StrExactMatch("diffball"))
assert list(
x.version
for x in self.repo.itermatch(rp, sorter=sorted)) == ["0.7", "1.0"]
assert \
self.repo.match(packages.OrRestriction(rc, rp), sorter=sorted) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2"))
assert \
sorted(self.repo.itermatch(packages.AndRestriction(rc, rp))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0"))
assert sorted(self.repo) == self.repo.match(packages.AlwaysTrue,
sorter=sorted)
# mix/match cat/pkg to check that it handles that corner case
# properly for sorting.
assert \
sorted(self.repo, reverse=True) == \
self.repo.match(packages.OrRestriction(
rc, rp, packages.AlwaysTrue),
sorter=partial(sorted, reverse=True))
rc2 = packages.PackageRestriction("category",
values.StrExactMatch("dev-lib"))
assert sorted(self.repo.itermatch(packages.AndRestriction(rp,
rc2))) == []
# note this mixes a category level match, and a pkg level
# match. they *must* be treated as an or.
assert \
sorted(self.repo.itermatch(packages.OrRestriction(rp, rc2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
# this is similar to the test above, but mixes a cat/pkg
# candidate with a pkg candidate
rp2 = packages.PackageRestriction("package",
values.StrExactMatch("fake"))
r = packages.OrRestriction(atom("dev-util/diffball"), rp2)
assert \
sorted(self.repo.itermatch(r)) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(
packages.OrRestriction(packages.AlwaysTrue, rp2))) == \
sorted(VersionedCPV(x) for x in (
"dev-util/diffball-0.7", "dev-util/diffball-1.0",
"dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-util', negate=True)))) == \
sorted(VersionedCPV(x) for x in ("dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
obj = malleable_obj(livefs=False)
pkg_cls = post_curry(MutatedPkg, {'repo': obj})
assert \
sorted(self.repo.itermatch(boolean.AndRestriction(boolean.OrRestriction(
packages.PackageRestriction(
"repo.livefs", values.EqualityMatch(False)),
packages.PackageRestriction(
"category", values.StrExactMatch("virtual"))),
atom("dev-lib/fake")),
pkg_cls=pkg_cls)) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True),
negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
assert \
sorted(self.repo.itermatch(packages.PackageRestriction(
'category', values.StrExactMatch('dev-lib', negate=True), negate=True))) == \
sorted(VersionedCPV(x) for x in (
"dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
