refactor GemVersion

Signed-off-by: Keshav Priyadarshi <[email protected]>

Author: keshav-space

src/univers/gem.py

@@ -199,19 +199,14 @@ def __init__(self, version):
         if not self.is_correct(version):
             raise InvalidVersionError(version)
 
-        # If version is an empty string convert it to 0
         version = str(version).strip()
-
         self.original = version
 
+        # If version is an empty string convert it to 0
         if not version:
             version = "0"
 
         self.version = version.replace("-", ".pre.")
-        self._segments = ()
-        self._canonical_segments = ()
-        self._bump = None
-        self._release = None
 
     def __str__(self):
         return self.original
@@ -225,7 +220,7 @@ def equal_strictly(self, other):
         return self.version == other.version
 
     def __hash__(self):
-        return hash(self.canonical_segments)
+        return hash(tuple(self.canonical_segments))
 
     def __eq__(self, other):
         return self.canonical_segments == other.canonical_segments
@@ -242,6 +237,33 @@ def __gt__(self, other):
     def __ge__(self, other):
         return self.__cmp__(other) >= 0
 
+    @property
+    def segments(self):
+        """
+        Return a new sequence of segments for this version where segments are
+        ints or strings parsed from the original version string.
+        """
+        find_segments = re.compile(r"[0-9]+|[a-z]+", re.IGNORECASE).findall
+        segments = []
+        for seg in find_segments(self.version):
+            if seg.isdigit():
+                seg = int(seg)
+            segments.append(seg)
+        return segments
+
+    @property
+    def canonical_segments(self):
+        """
+        Return a new sequence of "canonical segments" for this version using
+        the Rubygems way.
+        """
+        canonical_segments = []
+        for segments in self.split_segments():
+            segs = list(dropwhile(lambda s: s == 0, reversed(segments)))
+            segs = reversed(segs)
+            canonical_segments.extend(segs)
+        return canonical_segments
+
     def bump(self):
         """
         Return a new version object where the next to the last revision number
@@ -252,40 +274,33 @@ def bump(self):
         >>> assert GemVersion("5.3.1").bump() == GemVersion("5.4"), repr(GemVersion("5.3.1").bump())
         >>> assert GemVersion("5.3.1.4-2").bump() == GemVersion("5.3.2"), GemVersion("5.3.1.4-2").bump()
         """
-        if not self._bump:
-            segments = []
-            for seg in self.segments:
-                if isinstance(seg, str):
-                    break
-                else:
-                    segments.append(seg)
-
-            if len(segments) > 1:
-                segments.pop()
+        segments = []
+        for seg in self.segments:
+            if isinstance(seg, str):
+                break
+            else:
+                segments.append(seg)
 
-            segments[-1] += 1
-            segments = [str(r) for r in segments]
-            self._bump = GemVersion(".".join(segments))
+        if len(segments) > 1:
+            segments.pop()
 
-        return self._bump
+        segments[-1] += 1
+        segments = [str(r) for r in segments]
+        return GemVersion(".".join(segments))
 
     def release(self):
         """
         Return a new GemVersion which is the release for this version (e.g.,
         1.2.0.a -> 1.2.0). Non-prerelease versions return themselves. A release
         is composed only of numeric segments.
         """
-        if not self._release:
-            if self.prerelease():
-                segments = self.segments
-                while any(isinstance(s, str) for s in segments):
-                    segments.pop()
-                segments = (str(s) for s in segments)
-                self._release = GemVersion(".".join(segments))
-            else:
-                self._release = self
-
-        return self._release
+        if self.prerelease():
+            segments = self.segments
+            while any(isinstance(s, str) for s in segments):
+                segments.pop()
+            segments = (str(s) for s in segments)
+            return GemVersion(".".join(segments))
+        return self
 
     def prerelease(self):
         """
@@ -294,47 +309,6 @@ def prerelease(self):
         """
         return any(not str(s).isdigit() for s in self.segments)
 
-    @property
-    def segments(self):
-        """
-        Return a new sequence of segments for this version where segments are
-        ints or strings parsed from the original version string.
-        """
-        if not self._segments:
-            self._segments = self.get_segments()
-        return list(self._segments)
-
-    def get_segments(self):
-        """
-        Return a sequence of segments for this version where segments are ints
-        or strings parsed from the original version string.
-        """
-        find_segments = re.compile(r"[0-9]+|[a-z]+", re.IGNORECASE).findall
-        segments = []
-        for seg in find_segments(self.version):
-            if seg.isdigit():
-                seg = int(seg)
-            segments.append(seg)
-        return tuple(segments)
-
-    @property
-    def canonical_segments(self):
-        if not self._canonical_segments:
-            self._canonical_segments = self.get_canonical_segments()
-        return list(self._canonical_segments)
-
-    def get_canonical_segments(self):
-        """
-        Return a new sequence of "canonical segments" for this version using
-        the Rubygems way.
-        """
-        canonical_segments = []
-        for segments in self.split_segments():
-            segs = list(dropwhile(lambda s: s == 0, reversed(segments)))
-            segs = reversed(segs)
-            canonical_segments.extend(segs)
-        return tuple(canonical_segments)
-
     def split_segments(self):
         """
          Return a two-tuple of segments: