- better version parsing with regex from packaging

src/App/tests/test_getZopeVersion.py

@@ -15,7 +15,6 @@
 
 import unittest
 
-from packaging import version
 from pkg_resources import get_distribution
 
 from App.version_txt import getZopeVersion
@@ -71,6 +70,13 @@ def test__parse_version_data(self):
         self.assertEqual(parsed.status, '')
         self.assertEqual(parsed.release, -1)
 
+        parsed = _parse_version_data('5.1a2.dev0')
+        self.assertEqual(parsed.major, 5)
+        self.assertEqual(parsed.minor, 1)
+        self.assertEqual(parsed.micro, '0a2')
+        self.assertEqual(parsed.status, 'dev')
+        self.assertEqual(parsed.release, 0)
+
         parsed = _parse_version_data('5.1.2')
         self.assertEqual(parsed.major, 5)
         self.assertEqual(parsed.minor, 1)
@@ -85,28 +91,31 @@ def test__parse_version_data(self):
         self.assertEqual(parsed.status, 'dev')
         self.assertEqual(parsed.release, 0)
 
+        parsed = _parse_version_data('5.1.3a1.dev0')
+        self.assertEqual(parsed.major, 5)
+        self.assertEqual(parsed.minor, 1)
+        self.assertEqual(parsed.micro, '3a1')
+        self.assertEqual(parsed.status, 'dev')
+        self.assertEqual(parsed.release, 0)
+
     def test_complete(self):
-        distversion = version.parse(get_distribution('Zope').version)
+        positions = {
+            0: 'major',
+            1: 'minor',
+            2: 'micro',
+            3: 'status',
+            4: 'release',
+        }
+        distversion = get_distribution('Zope').version
         zversion = getZopeVersion()
 
-        major = distversion.release[0]
-        minor = micro = 0
-
-        if len(distversion.release) > 1:
-            minor = distversion.release[1]
-        if len(distversion.release) > 2:
-            micro = distversion.release[2]
-
-        self.assertEqual(zversion.major, major)
-        self.assertEqual(zversion.minor, minor)
-
-        if distversion.pre:
-            exp_micro = '%s%s' % (micro,
-                                  ''.join([str(x) for x in distversion.pre]))
-        else:
-            exp_micro = micro
-        self.assertEqual(zversion.micro, exp_micro)
-
-        if distversion.dev is not None:
-            self.assertEqual(zversion.status, 'dev')
-            self.assertEqual(zversion.release, distversion.dev)
+        for (pos, value) in enumerate(distversion.split('.')):
+            if pos < 2:
+                self.assertEqual(int(value), getattr(zversion, positions[pos]))
+            elif pos == 2:
+                # Could be int or string
+                self.assertEqual(value, str(getattr(zversion, positions[pos])))
+            elif pos == 3:
+                zstatus = getattr(zversion, positions[pos])
+                zrelease = getattr(zversion, positions[pos + 1])
+                self.assertEqual(value, '%s%s' % (zstatus, zrelease))

src/App/version_txt.py

@@ -23,6 +23,36 @@
 ZopeVersion = collections.namedtuple(
     "ZopeVersion",
     ["major", "minor", "micro", "status", "release"])
+VERSION_PATTERN = r"""
+    v?
+    (?:
+        (?:(?P<epoch>[0-9]+)!)?                           # epoch
+        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
+        (?P<pre>                                          # pre-release
+            [-_\.]?
+            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
+            [-_\.]?
+            (?P<pre_n>[0-9]+)?
+        )?
+        (?P<post>                                         # post release
+            (?:-(?P<post_n1>[0-9]+))
+            |
+            (?:
+                [-_\.]?
+                (?P<post_l>post|rev|r)
+                [-_\.]?
+                (?P<post_n2>[0-9]+)?
+            )
+        )?
+        (?P<dev>                                          # dev release
+            [-_\.]?
+            (?P<dev_l>dev)
+            [-_\.]?
+            (?P<dev_n>[0-9]+)?
+        )?
+    )
+    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
+"""
 
 
 def _prep_version_data():
@@ -36,17 +66,20 @@ def _prep_version_data():
 
 
 def _parse_version_data(version_string):
-    expr = re.compile(
-        r'(?P<major>[0-9]+)\.(?P<minor>[0-9]+)(\.(?P<micro>[0-9]+))?'
-        r'\.(?P<status>[A-Za-z]+)?(?P<release>[0-9]+)?')
+    expr = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$",
+                      re.VERBOSE | re.IGNORECASE)
     version_dict = expr.match(version_string).groupdict()
+    rel = tuple(int(i) for i in version_dict['release'].split('.'))
+    micro = rel[2] if len(rel) >= 3 else 0
+    if version_dict['pre']:
+        micro = '%s%s' % (micro, version_dict['pre'])
 
     return ZopeVersion(
-        int(version_dict.get('major') or -1),
-        int(version_dict.get('minor') or -1),
-        int(version_dict.get('micro') or 0),
-        version_dict.get('status') or '',
-        int(version_dict.get('release') or -1))
+        rel[0] if len(rel) >= 1 else 0,
+        rel[1] if len(rel) >= 2 else 0,
+        micro,
+        version_dict.get('dev_l') or '',
+        int(version_dict.get('dev_n') or -1))
 
 
 def version_txt():