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"))