New Atom implementation

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

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