Make version classes immutable

src/main/java/com/github/zafarkhaja/semver/AlphaNumericVersion.java

@@ -32,7 +32,7 @@ import java.util.regex.Pattern;
  */
 class AlphaNumericVersion implements Comparable<AlphaNumericVersion> {
 
-    private String value;
+    private final String value;
 
     static final String FORMAT = "([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)";
     private static final Pattern PATTERN = Pattern.compile("^" + FORMAT + "$");

src/main/java/com/github/zafarkhaja/semver/NormalVersion.java

@@ -32,9 +32,9 @@ import java.util.regex.Pattern;
  */
 class NormalVersion implements Comparable<NormalVersion> {
 
-    private int major;
+    private final int major;
-    private int minor;
+    private final int minor;
-    private int patch;
+    private final int patch;
 
     static final String FORMAT = "(\\d+)\\.(\\d+)\\.(\\d+)";
     private static final Pattern PATTERN = Pattern.compile("^" + FORMAT + "$");
@@ -74,19 +74,16 @@ class NormalVersion implements Comparable<NormalVersion> {
         return patch;
     }
 
-    void incrementMajor() {
+    NormalVersion incrementMajor() {
-        major = major + 1;
+        return new NormalVersion(major + 1, 0, 0);
-        minor = 0;
-        patch = 0;
     }
 
-    void incrementMinor() {
+    NormalVersion incrementMinor() {
-        minor = minor + 1;
+        return new NormalVersion(major, minor + 1, 0);
-        patch = 0;
     }
 
-    void incrementPatch() {
+    NormalVersion incrementPatch() {
-        patch = patch + 1;
+        return new NormalVersion(major, minor, patch + 1);
     }
 
     @Override

src/main/java/com/github/zafarkhaja/semver/Version.java

@@ -32,9 +32,9 @@ import java.util.regex.Pattern;
  */
 public class Version implements Comparable<Version> {
 
-    private NormalVersion normal;
+    private final NormalVersion normal;
-    private AlphaNumericVersion preRelease;
+    private final AlphaNumericVersion preRelease;
-    private AlphaNumericVersion build;
+    private final AlphaNumericVersion build;
 
     private static final String PRE_RELEASE_PREFIX = "-";
     private static final String BUILD_PREFIX = "+";
@@ -92,16 +92,16 @@ public class Version implements Comparable<Version> {
         return new Version(normal, preRelease, build);
     }
 
-    public void incrementMajorVersion() {
+    public Version incrementMajorVersion() {
-        normal.incrementMajor();
+        return new Version(normal.incrementMajor(), preRelease, build);
     }
 
-    public void incrementMinorVersion() {
+    public Version incrementMinorVersion() {
-        normal.incrementMinor();
+        return new Version(normal.incrementMinor(), preRelease, build);
     }
 
-    public void incrementPatchVersion() {
+    public Version incrementPatchVersion() {
-        normal.incrementPatch();
+        return new Version(normal.incrementPatch(), preRelease, build);
     }
 
     public int getMajorVersion() {

src/test/java/com/github/zafarkhaja/semver/NormalVersionTest.java

@@ -72,30 +72,30 @@ public class NormalVersionTest {
         public void mustIncreaseEachElementNumericallyByIncrementsOfOne() {
             int major = 1, minor = 2, patch = 3;
             NormalVersion v = new NormalVersion(major, minor, patch);
-            v.incrementPatch();
+            NormalVersion incrementedPatch = v.incrementPatch();
-            assertEquals(patch + 1, v.getPatch());
+            assertEquals(patch + 1, incrementedPatch.getPatch());
-            v.incrementMinor();
+            NormalVersion incrementedMinor = v.incrementMinor();
-            assertEquals(minor + 1, v.getMinor());
+            assertEquals(minor + 1, incrementedMinor.getMinor());
-            v.incrementMajor();
+            NormalVersion incrementedMajor = v.incrementMajor();
-            assertEquals(major + 1, v.getMajor());
+            assertEquals(major + 1, incrementedMajor.getMajor());
         }
 
         @Test
         public void mustResetMinorAndPatchToZeroWhenMajorIsIncremented() {
             NormalVersion v = new NormalVersion(1, 2, 3);
-            v.incrementMajor();
+            NormalVersion incremented = v.incrementMajor();
-            assertEquals(2, v.getMajor());
+            assertEquals(2, incremented.getMajor());
-            assertEquals(0, v.getMinor());
+            assertEquals(0, incremented.getMinor());
-            assertEquals(0, v.getPatch());
+            assertEquals(0, incremented.getPatch());
         }
 
         @Test
         public void mustResetPatchToZeroWhenMinorIsIncremented() {
             NormalVersion v = new NormalVersion(1, 2, 3);
-            v.incrementMinor();
+            NormalVersion incremented = v.incrementMinor();
-            assertEquals(1, v.getMajor());
+            assertEquals(1, incremented.getMajor());
-            assertEquals(3, v.getMinor());
+            assertEquals(3, incremented.getMinor());
-            assertEquals(0, v.getPatch());
+            assertEquals(0, incremented.getPatch());
         }
 
         @Test
@@ -122,6 +122,17 @@ public class NormalVersionTest {
             assertEquals(2, v.getMinor());
             assertEquals(3, v.getPatch());
         }
+        
+        @Test
+        public void shoudBeImmutable() {
+            NormalVersion version = new NormalVersion(1, 2, 3);
+            NormalVersion incementedMajor = version.incrementMajor();
+            assertNotSame(version, incementedMajor);
+            NormalVersion incementedMinor = version.incrementMinor();
+            assertNotSame(version, incementedMinor);
+            NormalVersion incementedPatch = version.incrementPatch();
+            assertNotSame(version, incementedPatch);
+        }
     }
 
     public static class EqualsMethodTest {

src/test/java/com/github/zafarkhaja/semver/VersionTest.java

@@ -154,22 +154,33 @@ public class VersionTest {
         @Test
         public void shouldProvideIncrementMajorVersionMethod() {
             Version v = Version.valueOf("1.2.3");
-            v.incrementMajorVersion();
+            Version incrementedMajor = v.incrementMajorVersion();
-            assertEquals("2.0.0", v.toString());
+            assertEquals("2.0.0", incrementedMajor.toString());
         }
 
         @Test
         public void shouldProvideIncrementMinorVersionMethod() {
             Version v = Version.valueOf("1.2.3");
-            v.incrementMinorVersion();
+            Version incrementedMinor = v.incrementMinorVersion();
-            assertEquals("1.3.0", v.toString());
+            assertEquals("1.3.0", incrementedMinor.toString());
         }
 
         @Test
         public void shouldProvideIncrementPatchVersionMethod() {
             Version v = Version.valueOf("1.2.3");
-            v.incrementPatchVersion();
+            Version incrementedPatch = v.incrementPatchVersion();
-            assertEquals("1.2.4", v.toString());
+            assertEquals("1.2.4", incrementedPatch.toString());
+        }
+        
+        @Test
+        public void shouldBeImmutable() {
+            Version version = Version.valueOf("1.2.3");
+            Version incementedMajor = version.incrementMajorVersion();
+            assertNotSame(version, incementedMajor);
+            Version incementedMinor = version.incrementMinorVersion();
+            assertNotSame(version, incementedMinor);
+            Version incementedPatch = version.incrementPatchVersion();
+            assertNotSame(version, incementedPatch);
         }
     }