add function to judge version number increases and make use of it

1 files changed, 71 insertions, 5 deletions

diff --git a/mgagnome b/mgagnome
index 198599f..4984a6e 100755
--- a/mgagnome
+++ b/mgagnome
@@ -62,6 +62,72 @@ def get_latest_version(versions, max_version=None):
             latest = version
     return latest
 
+def judge_version_increase(version_old, version_new):
+        """Judge quality of version increase:
+
+        Returns a tuple containing judgement and message
+
+        Judgement:
+        Less than 0: Error
+        0 to 4: Better not
+        5+: Ok"""
+        versions = (version_old, version_new)
+
+        print " => ".join(versions)
+
+        # First do a basic version comparison to ensure version_new is actually newer
+        compare = version_cmp(version_new, version_old)
+
+        if compare == 0:
+            return (-2, "Already at version %s!" % (version_old))
+
+        if compare != 1:
+            return (-3, "Version %s is older than current version %s!" % (version_new, version_old))
+
+        # Version is newer, but we don't want to see if it follows the GNOME versioning scheme
+        majmins = [re_majmin.sub(r'\1', ver) for ver in versions if re_majmin.match(ver) is not None]
+
+        if len(majmins) == 1:
+            return (-1, "Version number scheme changes: %s" % (", ".join(versions)))
+
+        if len(majmins) == 0:
+            return (0, "Unsupported version numbers: %s" % (", ".join(versions)))
+
+        # Follows GNOME versioning scheme
+        # Meaning: x.y.z
+        #          x = major
+        #          y = minor  : even if stable
+        #          z = micro
+
+        # Major+minor the same? Then go ahead and upgrade!
+        if majmins[0] == majmins[1]:
+            # Majmin of both versions are the same, looks good!
+            return (10, None)
+
+        # More detailed analysis needed, so figure out the numbers
+        majmin_nrs = [map(long, ver.split('.')) for ver in majmins]
+
+        # Check/ensure major version number is the same
+        if majmin_nrs[0][0] != majmin_nrs[1][0]:
+            return (1, "Major version number increase")
+
+        # Minor indicates stable/unstable
+        devstate = (majmin_nrs[0][1] % 2 == 0, majmin_nrs[1][1] % 2 == 0)
+
+        # Upgrading to unstable is weird
+        if not devstate[1]:
+            if devstate[0]:
+                return (1, "Stable to unstable increase")
+
+            return (4, "Unstable to unstable version increase")
+
+        # Unstable => stable is always ok
+        if not devstate[0]:
+            return (5, "Unstable to stable")
+
+        # Can only be increase of minors from one stable to the next
+        return (6, "Stable version increase")
+
 def line_input (file):
     for line in file:
         if line[-1] == '\n':
@@ -153,14 +219,14 @@ class SpecFile(object):
         """Update specfile (increase version)"""
         cur_version = self.version
 
-        compare = version_cmp(version, cur_version)
+        (judgement, msg) = judge_version_increase(cur_version, version)
 
-        if compare == 0:
-            print >>sys.stderr, "ERROR: Already at version %s!" % (cur_version)
+        if judgement < 0:
+            print >>sys.stderr, "ERROR: %s!" % (msg)
             return False
 
-        if compare != 1:
-            print >>sys.stderr, "ERROR: Version %s is older than current version %s!" % (version, cur_version)
+        if judgement < 5:
+            print >>sys.stderr, "WARNING: %s!" % (msg)
             return False
 
         # XXX - os.path.join is hackish