New Atom implementation

ebuildtester/atom.py

@@ -1,45 +1,88 @@
+import re
+
+from portage.dbapi.dep_expand import dep_expand
+from portage.versions import cpv_getversion
+import portage.exception as pe
+
+
 class AtomException(Exception):
     pass
 
 
 class Atom(object):
 
     def __init__(self, atom):
-        # We expect an atom of the form [=]CATEGORY/PACKAGE[-VERSION].
-        self.category = None
-        self.package = None
-        self.version = None
+        try:
+            # We expect an atom of the form [=]CATEGORY/PACKAGE[-VERSION].
+            self.atom = dep_expand(str(atom))
+        except pe.InvalidAtom:
+            raise AtomException(
+                "ATOM has to be of the form [=]SECTION/PACKAGE[-VERSION]")
 
-        # We don't store the optional '='.
-        temp = atom.split("=")
-        self.atom = temp[-1]
+        self.category = self.atomCategory()
+        self.package = self.atomName()
+        self.version = self.atomVersion()
+        self.repo = self.atomRepo()
 
-        try:
-            self.category, self.package = self.atom.split("/")
-        except ValueError:
+    def _splitPackage(self):
+        return self.atom.split("/", 1)
+
+    def atomCategory(self):
+        """Returns the package category without name"""
+        category = re.sub('^.*(=|<|>|~)', '', self._splitPackage()[0])
+        if category == 'null':
             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
+        return category
 
-    def __str__(self):
+    def atomName(self):
+        """Returns the package name without category"""
+        pkg = self._splitPackage()[1]
+        suffix = ['-' + str(self.atomVersion()),
+                  '::' + str(self.atomRepo())]
+        for s in suffix:
+            pkg = pkg.replace(s, '')
+
+        return pkg
+
+    def atomVersion(self):
+        """Returns the package version"""
+
+        return cpv_getversion(self.atom)
+
+    def atomRepo(self):
+        """Returns the package repository"""
+        pkg = self._splitPackage()[1].split("::", 1)
+        if len(pkg) == 2:
+            return pkg[1]
+
+    def atomCatName(self):
+        """Returns the package category and name without version"""
+        return "/".join([self.category, self.package])
+
+    def atomComplete(self):
+        """Returns a portage compatible string representation"""
+        suff = []
+        pref = ''
         if self.version is not None:
-            prefix = "="
-            suffix = "-" + self.version
-        else:
-            prefix = ""
-            suffix = ""
-        return prefix + self.category + "/" + self.package + suffix
+            suff += ['-' + self.version]
+            pref = '='
+
+        if self.repo is not None:
+            suff += ['::' + self.repo]
+
+        return (pref + self.category + '/' + self.package +
+                ''.join([str(s) for s in suff]))
+
+    def __str__(self):
+        return self.atomComplete()
 
     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):

requirements.txt

@@ -1,4 +1,5 @@
 bandit
+git+https://github.com/gentoo/[email protected]#egg=portage
 pycodestyle
 pytest
 sphinx

tests/test_atom.py

@@ -28,3 +28,50 @@ 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_atomRepo(self):
+        self.assertEqual(Atom(
+            "=CATEGORY/PACKAGE-1::REP-0").atomRepo(), "REP-0")
+        self.assertEqual(Atom(
+            "<=CATEGORY/PACKAGE-1.0.0::REPO-NAME").atomRepo(), "REPO-NAME")
+        self.assertEqual(Atom(
+            "CATEGORY/PACKAGE::REPO_NAME").atomRepo(), "REPO_NAME")
+
+    def test_atomCatName(self):
+        self.assertEqual(Atom("CATEGORY/PACKAGE").atomCatName(),
+                         "CATEGORY/PACKAGE")
+        self.assertEqual(Atom("=CATEGORY/PACKAGE-1.0").atomCatName(),
+                         "CATEGORY/PACKAGE")
+
+    def test_atomComplete(self):
+        atom1 = Atom("=CATEGORY/PACKAGE-1.0.0::REPO")
+        atom2 = Atom(atom1.atomComplete())
+        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.atomComplete(), "=CATEGORY/PACKAGE-DEP-1.0b-r1")