add SemVersion.ParsedFrom

Author: WalkerCodeRanger

Semver.Test/SemVersionConstructorTests.cs

@@ -88,7 +88,7 @@ public void ConstructWithMajorMinorPatchTest(int major, int minor, int patch)
         }
         #endregion
 
-        #region SemVersion(int major, int minor = 0, int patch = 0, string prerelease, string build)
+        #region SemVersion(int major, int minor = 0, int patch = 0, string prerelease = "", string build = "")
         /// <summary>
         /// Verifies the default values of the arguments to the primary constructor.
         /// </summary>
@@ -232,7 +232,8 @@ public void ConstructWithIdentifiersTest()
         [InlineData(0, -1, -1, InvalidMinorVersionMessage, "minor")]
         public void ConstructWithIdentifiersInvalidTest(int major, int minor, int patch, string expectedMessage, string expectedParamName)
         {
-            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new SemVersion(major, minor, patch, Enumerable.Empty<PrereleaseIdentifier>()));
+            var ex = Assert.Throws<ArgumentOutOfRangeException>(()
+                => new SemVersion(major, minor, patch, Enumerable.Empty<PrereleaseIdentifier>()));
 
             Assert.StartsWith(expectedMessage, ex.Message);
             Assert.Equal(expectedParamName, ex.ParamName);
@@ -294,5 +295,149 @@ public void ConstructWithStringIdentifiersInvalidTest(int major, int minor, int
 
         // TODO add tests for validation of prerelease and metadata
         #endregion
+
+        #region SemVersion.ParsedFrom(int major, int minor = 0, int patch = 0, string prerelease, string build)
+        [Fact]
+        public void ParsedFromDefaultValuesTest()
+        {
+            var v = SemVersion.ParsedFrom(1);
+
+            Assert.Equal(1, v.Major);
+            Assert.Equal(0, v.Minor);
+            Assert.Equal(0, v.Patch);
+            Assert.Equal("", v.Prerelease);
+            Assert.Empty(v.PrereleaseIdentifiers);
+            Assert.Equal("", v.Metadata);
+            Assert.Empty(v.MetadataIdentifiers);
+        }
+
+        [Fact]
+        public void ParsedFromTest()
+        {
+            var v = SemVersion.ParsedFrom(2, 3, 4, "pre.42", "build.42");
+
+            Assert.Equal(2, v.Major);
+            Assert.Equal(3, v.Minor);
+            Assert.Equal(4, v.Patch);
+            Assert.Equal("pre.42", v.Prerelease);
+            var expectedPrereleaseIdentifiers = new[] { new PrereleaseIdentifier("pre"), new PrereleaseIdentifier(42) };
+            Assert.Equal(expectedPrereleaseIdentifiers, v.PrereleaseIdentifiers);
+            Assert.Equal("build.42", v.Metadata);
+            var expectedMetadata = new[] { new MetadataIdentifier("build"), new MetadataIdentifier("42") };
+            Assert.Equal(expectedMetadata, v.MetadataIdentifiers);
+        }
+
+        [Theory]
+        [InlineData(-1, 0, 0, InvalidMajorVersionMessage, "major")]
+        [InlineData(0, -1, 0, InvalidMinorVersionMessage, "minor")]
+        [InlineData(0, 0, -1, InvalidPatchVersionMessage, "patch")]
+        [InlineData(-1, -1, -1, InvalidMajorVersionMessage, "major")]
+        [InlineData(0, -1, -1, InvalidMinorVersionMessage, "minor")]
+        public void ParsedFromInvalidTest(
+            int major,
+            int minor,
+            int patch,
+            string expectedMessage,
+            string expectedParamName)
+        {
+            var ex = Assert.Throws<ArgumentOutOfRangeException>(()
+                => SemVersion.ParsedFrom(major, minor, patch));
+
+            Assert.StartsWith(expectedMessage, ex.Message);
+            Assert.Equal(expectedParamName, ex.ParamName);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseEmptyString()
+        {
+            var v = SemVersion.ParsedFrom(1, 2, 3, "");
+
+            Assert.Equal(new SemVersion(1, 2, 3), v);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseEmptyIdentifier()
+        {
+            var ex = Assert.Throws<ArgumentException>(() => SemVersion.ParsedFrom(1, 2, 3, "bar."));
+            Assert.StartsWith("Prerelease identifier cannot be empty.", ex.Message);
+            Assert.Equal("prerelease", ex.ParamName);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseLeadingZeros()
+        {
+            var ex = Assert.Throws<ArgumentException>(()
+                => SemVersion.ParsedFrom(1, 2, 3, "bar.0123"));
+            Assert.StartsWith("Leading zeros are not allowed on numeric prerelease identifiers '0123'.", ex.Message);
+            Assert.Equal("prerelease", ex.ParamName);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseLeadingZerosAllowed()
+        {
+            var v = SemVersion.ParsedFrom(1, 2, 3, "bar.0123", allowLeadingZeros: true);
+
+            Assert.Equal(new SemVersion(1, 2, 3, "bar.123"), v);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseTooLarge()
+        {
+            var ex = Assert.Throws<OverflowException>(()
+               => SemVersion.ParsedFrom(1, 2, 3, "bar.99999999999999999"));
+            Assert.StartsWith("Prerelease identifier '99999999999999999' was too large for Int32.", ex.Message);
+        }
+
+        [Fact]
+        public void ParsedFromPrereleaseInvalidCharacter()
+        {
+            var ex = Assert.Throws<ArgumentException>(()
+                => SemVersion.ParsedFrom(1, 2, 3, "bar.abc@123"));
+            Assert.StartsWith("A prerelease identifier can contain only ASCII alphanumeric characters and hyphens 'abc@123'.", ex.Message);
+            Assert.Equal("prerelease", ex.ParamName);
+        }
+
+        [Fact]
+        public void ParsedFromMetadataEmptyString()
+        {
+            var v = SemVersion.ParsedFrom(1, metadata: "");
+
+            Assert.Equal(new SemVersion(1, 0, 0), v);
+        }
+
+        [Fact]
+        public void ParsedFromMetadataEmptyIdentifier()
+        {
+            var ex = Assert.Throws<ArgumentException>(()
+                => SemVersion.ParsedFrom(1, metadata: "bar."));
+            Assert.StartsWith("Metadata identifier cannot be empty.", ex.Message);
+            Assert.Equal("metadata", ex.ParamName);
+        }
+
+        [Fact]
+        public void ParsedFromMetadataLeadingZeros()
+        {
+            var v = SemVersion.ParsedFrom(1, metadata: "bar.0123");
+
+            Assert.Equal(new SemVersion(1, 0, 0, "", "bar.0123"), v);
+        }
+
+        [Fact]
+        public void ParsedFromMetadataTooLarge()
+        {
+            var v = SemVersion.ParsedFrom(1, metadata: "bar.99999999999999999");
+
+            Assert.Equal(new SemVersion(1, 0, 0, "", "bar.99999999999999999"), v);
+        }
+
+        [Fact]
+        public void ParsedFromMetadataInvalidCharacter()
+        {
+            var ex = Assert.Throws<ArgumentException>(()
+                => SemVersion.ParsedFrom(1, metadata: "bar.abc@123"));
+            Assert.StartsWith("A metadata identifier can contain only ASCII alphanumeric characters and hyphens 'abc@123'.", ex.Message);
+            Assert.Equal("metadata", ex.ParamName);
+        }
+        #endregion
     }
 }

Semver/PublicAPI/net452/PublicAPI.Unshipped.txt

@@ -70,4 +70,5 @@ static Semver.PrereleaseIdentifier.operator !=(Semver.PrereleaseIdentifier left,
 static Semver.PrereleaseIdentifier.operator ==(Semver.PrereleaseIdentifier left, Semver.PrereleaseIdentifier right) -> bool
 static Semver.SemVersion.FromVersion(System.Version version) -> Semver.SemVersion
 static Semver.SemVersion.Parse(string version, Semver.SemVersionStyles style, int maxLength = 1024) -> Semver.SemVersion
+static Semver.SemVersion.ParsedFrom(int major, int minor = 0, int patch = 0, string prerelease = "", string metadata = "", bool allowLeadingZeros = false) -> Semver.SemVersion
 static Semver.SemVersion.TryParse(string version, Semver.SemVersionStyles style, out Semver.SemVersion semver, int maxLength = 1024) -> bool

Semver/PublicAPI/netstandard1.1/PublicAPI.Unshipped.txt

@@ -70,4 +70,5 @@ static Semver.PrereleaseIdentifier.operator !=(Semver.PrereleaseIdentifier left,
 static Semver.PrereleaseIdentifier.operator ==(Semver.PrereleaseIdentifier left, Semver.PrereleaseIdentifier right) -> bool
 static Semver.SemVersion.FromVersion(System.Version version) -> Semver.SemVersion
 static Semver.SemVersion.Parse(string version, Semver.SemVersionStyles style, int maxLength = 1024) -> Semver.SemVersion
+static Semver.SemVersion.ParsedFrom(int major, int minor = 0, int patch = 0, string prerelease = "", string metadata = "", bool allowLeadingZeros = false) -> Semver.SemVersion
 static Semver.SemVersion.TryParse(string version, Semver.SemVersionStyles style, out Semver.SemVersion semver, int maxLength = 1024) -> bool

Semver/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt

@@ -70,4 +70,5 @@ static Semver.PrereleaseIdentifier.operator !=(Semver.PrereleaseIdentifier left,
 static Semver.PrereleaseIdentifier.operator ==(Semver.PrereleaseIdentifier left, Semver.PrereleaseIdentifier right) -> bool
 static Semver.SemVersion.FromVersion(System.Version version) -> Semver.SemVersion
 static Semver.SemVersion.Parse(string version, Semver.SemVersionStyles style, int maxLength = 1024) -> Semver.SemVersion
+static Semver.SemVersion.ParsedFrom(int major, int minor = 0, int patch = 0, string prerelease = "", string metadata = "", bool allowLeadingZeros = false) -> Semver.SemVersion
 static Semver.SemVersion.TryParse(string version, Semver.SemVersionStyles style, out Semver.SemVersion semver, int maxLength = 1024) -> bool

Semver/SemVersion.cs

@@ -254,6 +254,52 @@ public SemVersion(int major, int minor = 0, int patch = 0,
             }
         }
 
+        /// <summary>
+        /// Create a new instance of the <see cref="SemVersion" /> class. Parses prerelease
+        /// and metadata identifiers from dot separated strings. If parsing is not needed, use a
+        /// constructor instead.
+        /// </summary>
+        /// <param name="major">The major version number.</param>
+        /// <param name="minor">The minor version number.</param>
+        /// <param name="patch">The patch version number.</param>
+        /// <param name="prerelease">The prerelease portion (e.g. "alpha.5").</param>
+        /// <param name="metadata">The build metadata (e.g. "nightly.232").</param>
+        /// <param name="allowLeadingZeros">Allow leading zeros in numeric prerelease identifiers. Leading
+        /// zeros will be removed.</param>
+        /// <exception cref="ArgumentOutOfRangeException">A <paramref name="major"/>,
+        /// <paramref name="minor"/>, or <paramref name="patch"/> version number is negative.</exception>
+        /// <exception cref="ArgumentException">A prerelease identifier is empty or contains invalid
+        /// characters (i.e. characters that are not ASCII alphanumerics or hyphens) or has leading
+        /// zeros for a numeric identifier when <paramref name="allowLeadingZeros"/> is
+        /// <see langword="false"/>. Or, a metadata identifier is empty or contains invalid
+        /// characters (i.e. characters that are not ASCII alphanumerics or hyphens).</exception>
+        /// <exception cref="OverflowException">A numeric prerelease identifier value is too large
+        /// for <see cref="int"/>.</exception>
+        public static SemVersion ParsedFrom(int major, int minor = 0, int patch = 0,
+            string prerelease = "", string metadata = "", bool allowLeadingZeros = false)
+        {
+            if (major < 0) throw new ArgumentOutOfRangeException(nameof(major), InvalidMajorVersionMessage);
+            if (minor < 0) throw new ArgumentOutOfRangeException(nameof(minor), InvalidMinorVersionMessage);
+            if (patch < 0) throw new ArgumentOutOfRangeException(nameof(patch), InvalidPatchVersionMessage);
+
+            if (prerelease is null) throw new ArgumentNullException(nameof(prerelease));
+            var prereleaseIdentifiers = prerelease.Length == 0
+                ? ReadOnlyList<PrereleaseIdentifier>.Empty
+                : prerelease.SplitAndMapToReadOnlyList('.',
+                    i => new PrereleaseIdentifier(i, allowLeadingZeros, nameof(prerelease)));
+            if (allowLeadingZeros)
+                // Leading zeros may have been removed, need to reconstruct the prerelease string
+                prerelease = string.Join(".", prereleaseIdentifiers);
+
+            if (metadata is null) throw new ArgumentNullException(nameof(metadata));
+            var metadataIdentifiers = metadata.Length == 0
+                ? ReadOnlyList<MetadataIdentifier>.Empty
+                : metadata.SplitAndMapToReadOnlyList('.', i => new MetadataIdentifier(i, nameof(metadata)));
+
+            return new SemVersion(major, minor, patch,
+                prerelease, prereleaseIdentifiers, metadata, metadataIdentifiers);
+        }
+
         /// <summary>
         /// Constructs a new instance of the <see cref="SemVersion"/> class from
         /// a <see cref="Version"/>.
@@ -703,7 +749,7 @@ public SemVersion With(
         /// <exception cref="ArgumentException">A prerelease identifier is empty or contains invalid
         /// characters (i.e. characters that are not ASCII alphanumerics or hyphens) or has leading
         /// zeros for a numeric identifier when <paramref name="allowLeadingZeros"/> is
-        /// <see langword="false"/>. Or, metadata identifier is empty or contains invalid
+        /// <see langword="false"/>. Or, a metadata identifier is empty or contains invalid
         /// characters (i.e. characters that are not ASCII alphanumerics or hyphens).</exception>
         /// <exception cref="OverflowException">A numeric prerelease identifier value is too large
         /// for <see cref="int"/>.</exception>