Re-implement current functionality to be a bit more concise

Author: absurdfarce

cassandra/util.py

@@ -1709,24 +1709,26 @@ def __init__(self, version):
         self.minor = int(match[2])
 
         try:
-            self.patch = self._cleanup(match[3])
+            self.patch = self._cleanup_int(match[3])
         except:
             self.patch = 0
 
         try:
-            self.build = self._cleanup(match[4])
+            self.build = self._cleanup_int(match[4])
         except:
             self.build = 0
 
         try:
-            self.prerelease = self._cleanup_prerelease(match[5])
+            self.prerelease = self._cleanup_str(match[5])
         except:
             self.prerelease = 0
 
-    def _cleanup(self, s):
+    # Trim off the leading '.' characters and convert the discovered value to an integer
+    def _cleanup_int(self, s):
         return int(s[1:]) if s else 0
 
-    def _cleanup_prerelease(self, str):
+    # Trim off the leading '.' or '~' characters and just return the string directly
+    def _cleanup_str(self, str):
         return str[1:] if str else 0
 
     def __hash__(self):
@@ -1745,48 +1747,32 @@ def __repr__(self):
     def __str__(self):
         return self._version
 
-    @staticmethod
-    def _compare_version_part(version, other_version, cmp):
-        if not (isinstance(version, int) and
-                isinstance(other_version, int)):
-            version = str(version)
-            other_version = str(other_version)
-
-        return cmp(version, other_version)
-
     def __eq__(self, other):
         if not isinstance(other, Version):
             return NotImplemented
 
         return (self.major == other.major and
                 self.minor == other.minor and
                 self.patch == other.patch and
-                self._compare_version_part(self.build, other.build, lambda s, o: s == o) and
-                self._compare_version_part(self.prerelease, other.prerelease, lambda s, o: s == o)
+                self.build == other.build and
+                self.prerelease == other.prerelease
                 )
 
     def __gt__(self, other):
         if not isinstance(other, Version):
             return NotImplemented
 
-        is_major_ge = self.major >= other.major
-        is_minor_ge = self.minor >= other.minor
-        is_patch_ge = self.patch >= other.patch
-        is_build_gt = self._compare_version_part(self.build, other.build, lambda s, o: s > o)
-        is_build_ge = self._compare_version_part(self.build, other.build, lambda s, o: s >= o)
-
-        # By definition, a prerelease comes BEFORE the actual release, so if a version
-        # doesn't have a prerelease, it's automatically greater than anything that does
-        if self.prerelease and not other.prerelease:
-            is_prerelease_gt = False
+        if self.major != other.major:
+            return self.major > other.major
+        elif self.minor != other.minor:
+            return self.minor > other.minor
+        elif self.patch != other.patch:
+            return self.patch > other.patch
+        elif self.build != other.build:
+            return self.build > other.build
+        elif self.prerelease and not other.prerelease:
+            return False
         elif other.prerelease and not self.prerelease:
-            is_prerelease_gt = True
+            return True
         else:
-            is_prerelease_gt = self._compare_version_part(self.prerelease, other.prerelease, lambda s, o: s > o) \
-
-        return (self.major > other.major or
-                (is_major_ge and self.minor > other.minor) or
-                (is_major_ge and is_minor_ge and self.patch > other.patch) or
-                (is_major_ge and is_minor_ge and is_patch_ge and is_build_gt) or
-                (is_major_ge and is_minor_ge and is_patch_ge and is_build_ge and is_prerelease_gt)
-                )
+            return self.prerelease > other.prerelease