From 3887265bda745bc3638145ae01df6b0033357e0d Mon Sep 17 00:00:00 2001 From: Bernd Waibel Date: Fri, 12 Oct 2018 19:54:15 +0200 Subject: [PATCH] New Atom implementation Based off of gentooPackage.py from =app-portage/tatt-0.5 package, see https://github.com/gentoo/tatt/blob/master/tatt/gentooPackage.py Add tests --- ebuildtester/atom.py | 111 +++++++++++++++++++++++++++++++------------ tests/test_atom.py | 39 +++++++++++++++ 2 files changed, 119 insertions(+), 31 deletions(-) diff --git a/ebuildtester/atom.py b/ebuildtester/atom.py index 9fd1323..cbfb236 100644 --- a/ebuildtester/atom.py +++ b/ebuildtester/atom.py @@ -1,45 +1,94 @@ + +import re + + class AtomException(Exception): pass class Atom(object): + """A Gentoo Atom consists of the: + category + package (name) + version + of a Gentoo package""" def __init__(self, atom): - # We expect an atom of the form [=]CATEGORY/PACKAGE[-VERSION]. - self.category = None - self.package = None - self.version = None - - # We don't store the optional '='. - temp = atom.split("=") - self.atom = temp[-1] - - try: - self.category, self.package = self.atom.split("/") - except ValueError: - raise AtomException( - "ATOM has to be of the form [=]SECTION/PACKAGE[-VERSION]") - - # Split off version. - try: - temp = self.package.index("-") - if temp > -1: - self.version = self.package[temp + 1:] - self.package = self.package[:temp] - except ValueError: - pass + """We expect an atom of the form [=]CATEGORY/PACKAGE[-VERSION].""" + self.category = "" + self.package = "" + self.version = "" - def __str__(self): - if self.version is not None: - prefix = "=" - suffix = "-" + self.version + # strip off an optional leading = + atom = str(atom) + if atom[0] == "=": + atom = atom[1:] + + slashparts = atom.split("/") + if len(slashparts) == 1: + raise AtomException("Atoms must be of the form [=]CAT/PKG[-VER]!") + else: + self.category = slashparts[0] + self._split_version(slashparts[1]) + + def _split_version(self, pkg): + """Splits the version from an atom with version""" + minusparts = pkg.split("-") + if len(minusparts) == 1: + # no version given + self.package = pkg else: - prefix = "" - suffix = "" - return prefix + self.category + "/" + self.package + suffix + # parse the name-version part + while 1: + try: + p = minusparts.pop(0) + except IndexError: + break + + # try a number after a '-' + if re.match('[0-9]+', p): + # version starts here + self.version = "-".join([p] + minusparts) + break + else: + # append back to name + if self.package == "": + self.package = p + else: + self.package = "-".join([self.package, p]) + + def atomName(self): + """Returns the package name without category""" + return self.package + + def atomCategory(self): + """Returns the package category without name""" + return self.category + + def atomVersion(self): + """Returns the package version""" + return self.version + + def atomCatName(self): + """Returns the package category and name without version""" + return "/".join([self.category, self.package]) + + def atomString(self): + """Returns a portage compatible string representation""" + if self.version == "": + return self.atomCatName() + + return ("=" + "/".join([self.category, + "-".join([self.package, + self.version])])) + + def __str__(self): + return self.atomString() def __eq__(self, other): - result = (self.atom == other.atom) + result = (self.category == other.category + and self.package == other.package + and self.version == other.version) return result def __repr__(self): diff --git a/tests/test_atom.py b/tests/test_atom.py index 95f8343..14b4273 100644 --- a/tests/test_atom.py +++ b/tests/test_atom.py @@ -28,3 +28,42 @@ def test_str(self): atom_1 = Atom("=CATEGORY/PACKAGE-1.0.0-r1") atom_2 = Atom(str(atom_1)) self.assertEqual(atom_1, atom_2) + + def test_atomName(self): + self.assertEqual(Atom("CATEGORY/PACKAGE").atomName(), "PACKAGE") + self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0.0").atomName(), "PACKAGE") + self.assertEqual(Atom("CATEGORY/PACKAGE-1.0.0").atomName(), "PACKAGE") + self.assertEqual(Atom("=CATEGORY/PACKAGE-DEP-1.0b-r1").atomName(), + "PACKAGE-DEP") + + def test_atomCategory(self): + self.assertEqual(Atom("CATEGORY/PACKAGE").atomCategory(), "CATEGORY") + self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0.0").atomCategory(), + "CATEGORY") + + def test_atomVersion(self): + self.assertEqual(Atom("=CATEGORY/PACKAGE-1").atomVersion(), "1") + self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0").atomVersion(), "1.0") + self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0-r1").atomVersion(), + "1.0-r1") + self.assertEqual(Atom("=CATEGORY/PACKAGE-DEP-1.0b-r1").atomVersion(), + "1.0b-r1") + + def test_atomCatName(self): + self.assertEqual(Atom("CATEGORY/PACKAGE").atomCatName(), + "CATEGORY/PACKAGE") + self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0").atomCatName(), + "CATEGORY/PACKAGE") + + def test_atomString(self): + atom1 = Atom("=CATEGORY/PACKAGE-1.0.0") + atom2 = Atom(atom1.atomString()) + self.assertEqual(atom1, atom2) + + def test_atom(self): + atom1 = Atom("=CATEGORY/PACKAGE-DEP-1.0b-r1") + self.assertEqual(atom1.atomCategory(), "CATEGORY") + self.assertEqual(atom1.atomName(), "PACKAGE-DEP") + self.assertEqual(atom1.atomCatName(), "CATEGORY/PACKAGE-DEP") + self.assertEqual(atom1.atomVersion(), "1.0b-r1") + self.assertEqual(atom1.atomString(), "=CATEGORY/PACKAGE-DEP-1.0b-r1")