Ticket #2425: 0001-Add-class-to-parse-and-compare-the-bundles-version-n.patch

src/sugar/bundle/Makefile.am

@@ -3 +3 @@
         __init__.py                     \
         bundle.py                       \
         activitybundle.py               \
+        bundleversion.py                \
         contentbundle.py

new file src/sugar/bundle/bundleversion.py

@@ +1 @@
+# Copyright (C) 2010, OLPC
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+#
+# Based in the implementation of PEP 386, but adapted to our numeration schema
+#
+
+import re
+
+class InvalidVersionError(Exception):
+    """This is an not normalized version."""
+    pass
+
+VERSION_RE = re.compile(r'''
+    ^
+    (?P<version>\d+)               # minimum 'N'
+    (?P<extraversion>(?:\.\d+)*)   # any number of extra '.N' segments
+    (?:
+    (?P<local>\-[a-zA-Z]*)         # any string, will be ignored in the comparison
+    )?
+    $''', re.VERBOSE)
+
+class NormalizedVersion(object):
+    """A normalized version.
+
+    Good:
+        1
+        1.2
+        1.2.3
+        1.2.3-peru
+
+    Bad:
+        1.2peru        # must separate with -
+        1.2.           # can't end with .
+        1.02.5         # can't have a leading zero
+    """
+    def __init__(self, s, error_on_huge_major_num=True):
+        """Create a NormalizedVersion instance from a version string.
+
+        @param s {str} The version string.
+        @param error_on_huge_major_num {bool} Whether to consider an
+            apparent use of a year or full date as the major version number
+            an error. Default True. One of the observed patterns on PyPI before
+            the introduction of `NormalizedVersion` was version numbers like this:
+                2009.01.03
+                20040603
+                2005.01
+            This guard is here to strongly encourage the package author to
+            use an alternate version, because a release deployed into PyPI
+            and, e.g. downstream Linux package managers, will forever remove
+            the possibility of using a version number like "1.0" (i.e.
+            where the major number is less than that huge major number).
+        """
+        match = VERSION_RE.search(s)
+        if not match:
+            raise InvalidVersionError(s)
+
+        groups = match.groupdict()
+        parts = []
+
+        # main version
+        block = self._parse_numdots(groups['version'], s, False, 1)
+        extraversion = groups.get('extraversion')
+        if extraversion not in ('', None):
+            block += self._parse_numdots(extraversion[1:], s)
+        parts.extend(block)
+        self._parts = parts
+        self._local = groups['local']
+
+    def _parse_numdots(self, s, full_ver_str, drop_trailing_zeros=True,
+                       pad_zeros_length=0):
+        """Parse 'N.N.N' sequences, return a list of ints.
+
+        @param s {str} 'N.N.N..." sequence to be parsed
+        @param full_ver_str {str} The full version string from which this
+            comes. Used for error strings.
+        @param drop_trailing_zeros {bool} Whether to drop trailing zeros
+            from the returned list. Default True.
+        @param pad_zeros_length {int} The length to which to pad the
+            returned list with zeros, if necessary. Default 0.
+        """
+        nums = []
+        for n in s.split("."):
+            if len(n) > 1 and n[0] == '0':
+                raise InvalidVersionError("cannot have leading zero in "
+                    "version number segment: '%s' in %r" % (n, full_ver_str))
+            nums.append(int(n))
+        if drop_trailing_zeros:
+            while nums and nums[-1] == 0:
+                nums.pop()
+        while len(nums) < pad_zeros_length:
+            nums.append(0)
+        return nums
+
+    def get_parts(self):
+        return self._parts
+
+    def __str__(self):
+        s = self._parts_to_str(self._parts)
+        if self._local != None:
+            s = s + self._local
+        return s
+
+    @classmethod
+    def _parts_to_str(cls, parts):
+        """Transforms a version expressed in tuple into its string
+        representation."""
+        main = parts
+        s = '.'.join(str(v) for v in main)
+        return s
+
+    def __repr__(self):
+        return "%s('%s')" % (self.__class__.__name__, self)
+
+    def _cannot_compare(self, other):
+        raise TypeError("cannot compare %s and %s"
+                % (type(self).__name__, type(other).__name__))
+
+    def __eq__(self, other):
+        if not isinstance(other, NormalizedVersion):
+            self._cannot_compare(other)
+        return self._parts == other.get_parts()
+
+    def __lt__(self, other):
+        if not isinstance(other, NormalizedVersion):
+            self._cannot_compare(other)
+        return self._parts < other.get_parts()
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __gt__(self, other):
+        return not (self.__lt__(other) or self.__eq__(other))
+
+    def __le__(self, other):
+        return self.__eq__(other) or self.__lt__(other)
+
+    def __ge__(self, other):
+        return self.__eq__(other) or self.__gt__(other)
+

new file tests/lib/test_versions.py

@@ +1 @@
+"""Tests for sugar.bundle.version."""
+import unittest
+import doctest
+import os
+
+from sugar.bundle.bundleversion import NormalizedVersion as V
+from sugar.bundle.bundleversion import InvalidVersionError
+
+class VersionTestCase(unittest.TestCase):
+
+    versions = ((V('1.0'), '1'),
+                (V('1.1'), '1.1'),
+                (V('1.2.3'), '1.2.3'),
+                (V('1.2'), '1.2'),
+                (V('1.2.3'), '1.2.3'),
+                (V('1.2-peru'), '1.2-peru'),
+                (V('1.2.0.0.0'), '1.2'))
+
+    def test_basic_versions(self):
+
+        for v, s in self.versions:
+            self.assertEquals(str(v), s)
+
+
+    def test_not_normalized_versions(self):
+
+        irrational = ('1.', '1.2arg', '1-2-3','1.02.5')
+
+        for s in irrational:
+            self.assertRaises(InvalidVersionError, V, s)
+
+    def test_comparison(self):
+        """
+        >>> V('1.2.0') == '1.2'
+        Traceback (most recent call last):
+        ...
+        TypeError: cannot compare NormalizedVersion and str
+        >>> V('12') == V('12')
+        True
+        >>> V('1.2.0') == V('1.2')
+        True
+        >>> V('1.2.0') == V('1.2.3')
+        False
+        >>> V('1.2.0') < V('1.2.3')
+        True
+        >>> V('1.2-arg') == V('1.2')
+        True
+        >>> V('1.2-arg') == V('1.2-peru')
+        True
+        >>> V('1.2') < V('1.2.1')
+        True
+        """
+        # must be a simpler way to call the docstrings
+        doctest.run_docstring_examples(self.test_comparison, globals(),
+                                       name='test_comparison')
+
+def test_suite():
+    #README = os.path.join(os.path.dirname(__file__), 'README.txt')
+    #suite = [doctest.DocFileSuite(README), unittest.makeSuite(VersionTestCase)]
+    suite = [unittest.makeSuite(VersionTestCase)]
+    return unittest.TestSuite(suite)
+
+if __name__ == "__main__":
+    unittest.main(defaultTest="test_suite")
+