Always generate 4-component AssemblyVersion

Fix #26

Author: AArnott

src/NerdBank.GitVersioning.Tests/BuildIntegrationTests.cs

@@ -209,10 +209,14 @@ private void AssertStandardProperties(VersionOptions versionOptions, BuildResult
         Version idAsVersion = this.Repo.Head.Commits.First().GetIdAsVersion(relativeProjectDirectory);
         string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10);
         Version version = this.Repo.Head.Commits.First().GetIdAsVersion(relativeProjectDirectory);
-        Version assemblyVersion = versionOptions.AssemblyVersion ?? versionOptions.Version.Version;
+        Version assemblyVersion = (versionOptions.AssemblyVersion ?? versionOptions.Version.Version).EnsureNonNegativeComponents();
         Assert.Equal($"{version}", buildResult.AssemblyFileVersion);
         Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}+g{commitIdShort}", buildResult.AssemblyInformationalVersion);
-        Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}", buildResult.AssemblyVersion);
+
+        // The assembly version property should always have four integer components to it,
+        // per bug https://github.com/AArnott/Nerdbank.GitVersioning/issues/26
+        Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}.{assemblyVersion.Revision}", buildResult.AssemblyVersion);
+
         Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumber);
         Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable);
         Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstComponent);

src/NerdBank.GitVersioning.Tests/NerdBank.GitVersioning.Tests.csproj

@@ -79,6 +79,7 @@
     <Compile Include="RepoTestBase.cs" />
     <Compile Include="SemanticVersionTests.cs" />
     <Compile Include="TestUtilities.cs" />
+    <Compile Include="VersionExtensionsTests.cs" />
     <Compile Include="VersionFileTests.cs" />
     <Compile Include="VersionOptionsTests.cs" />
   </ItemGroup>

src/NerdBank.GitVersioning.Tests/VersionExtensionsTests.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Nerdbank.GitVersioning;
+using Xunit;
+
+public class VersionExtensionsTests
+{
+    [Fact]
+    public void EnsureNonNegativeComponents_NoValues()
+    {
+        var version = new Version().EnsureNonNegativeComponents();
+        Assert.Equal(0, version.Major);
+        Assert.Equal(0, version.Minor);
+        Assert.Equal(0, version.Build);
+        Assert.Equal(0, version.Revision);
+    }
+
+    [Fact]
+    public void EnsureNonNegativeComponents_2Values()
+    {
+        var version = new Version(1, 2).EnsureNonNegativeComponents();
+        Assert.Equal(1, version.Major);
+        Assert.Equal(2, version.Minor);
+        Assert.Equal(0, version.Build);
+        Assert.Equal(0, version.Revision);
+    }
+
+    [Fact]
+    public void EnsureNonNegativeComponents_3Values()
+    {
+        var version = new Version(1, 2, 3).EnsureNonNegativeComponents();
+        Assert.Equal(1, version.Major);
+        Assert.Equal(2, version.Minor);
+        Assert.Equal(3, version.Build);
+        Assert.Equal(0, version.Revision);
+    }
+
+    [Fact]
+    public void EnsureNonNegativeComponents_4Values()
+    {
+        var original = new Version(1, 2, 3, 4);
+        var version = original.EnsureNonNegativeComponents();
+        Assert.Same(original, version);
+    }
+
+    [Fact]
+    public void ToStringSafe()
+    {
+        Assert.Equal("1.2.3.4", new Version(1, 2, 3, 4).ToStringSafe(4));
+        Assert.Equal("1.2.3.0", new Version(1, 2, 3).ToStringSafe(4));
+        Assert.Equal("1.2.0.0", new Version(1, 2).ToStringSafe(4));
+
+        Assert.Equal("1.2.3", new Version(1, 2, 3, 4).ToStringSafe(3));
+        Assert.Equal("1.2.3", new Version(1, 2, 3).ToStringSafe(3));
+        Assert.Equal("1.2.0", new Version(1, 2).ToStringSafe(3));
+
+        Assert.Equal("1.2", new Version(1, 2, 3, 4).ToStringSafe(2));
+        Assert.Equal("1.2", new Version(1, 2, 3).ToStringSafe(2));
+        Assert.Equal("1.2", new Version(1, 2).ToStringSafe(2));
+
+        Assert.Equal("1", new Version(1, 2).ToStringSafe(1));
+
+        Assert.Equal(string.Empty, new Version(1, 2).ToStringSafe(0));
+    }
+}

src/NerdBank.GitVersioning/NerdBank.GitVersioning.csproj

@@ -62,6 +62,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SemanticVersion.cs" />
     <Compile Include="SemanticVersionJsonConverter.cs" />
+    <Compile Include="VersionExtensions.cs" />
     <Compile Include="VersionFile.cs" />
     <Compile Include="VersionOptions.cs" />
   </ItemGroup>

src/NerdBank.GitVersioning/VersionExtensions.cs

@@ -0,0 +1,73 @@
+namespace Nerdbank.GitVersioning
+{
+    using System;
+    using Validation;
+
+    /// <summary>
+    /// Extension methods for the <see cref="Version"/> class.
+    /// </summary>
+    public static class VersionExtensions
+    {
+        /// <summary>
+        /// Returns a <see cref="Version"/> instance where the specified number of components
+        /// are guaranteed to be non-negative. Any applicable negative components are converted to zeros.
+        /// </summary>
+        /// <param name="version">The version to use as a template for the returned value.</param>
+        /// <param name="fieldCount">The number of version components to ensure are non-negative.</param>
+        /// <returns>
+        /// The same as <paramref name="version"/> except with any applicable negative values
+        /// translated to zeros.
+        /// </returns>
+        public static Version EnsureNonNegativeComponents(this Version version, int fieldCount = 4)
+        {
+            Requires.NotNull(version, nameof(version));
+            Requires.Range(fieldCount >= 0 && fieldCount <= 4, nameof(fieldCount));
+
+            int maj = fieldCount >= 1 ? Math.Max(0, version.Major) : version.Major;
+            int min = fieldCount >= 2 ? Math.Max(0, version.Minor) : version.Minor;
+            int bld = fieldCount >= 3 ? Math.Max(0, version.Build) : version.Build;
+            int rev = fieldCount >= 4 ? Math.Max(0, version.Revision) : version.Revision;
+
+            if (version.Major == maj &&
+                version.Minor == min &&
+                version.Build == bld &&
+                version.Revision == rev)
+            {
+                return version;
+            }
+
+            if (rev >= 0)
+            {
+                return new Version(maj, min, bld, rev);
+            }
+            else if (bld >= 0)
+            {
+                return new Version(maj, min, bld);
+            }
+            else
+            {
+                throw Assumes.NotReachable();
+            }
+        }
+
+        /// <summary>
+        /// Converts the value of the current System.Version object to its equivalent System.String
+        /// representation. A specified count indicates the number of components to return.
+        /// </summary>
+        /// <param name="version">The instance to serialize as a string.</param>
+        /// <param name="fieldCount">The number of components to return. The fieldCount ranges from 0 to 4.</param>
+        /// <returns>
+        /// The System.String representation of the values of the major, minor, build, and
+        /// revision components of the current System.Version object, each separated by a
+        /// period character ('.'). The fieldCount parameter determines how many components
+        /// are returned.fieldCount Return Value 0 An empty string (""). 1 major 2 major.minor
+        /// 3 major.minor.build 4 major.minor.build.revision For example, if you create System.Version
+        /// object using the constructor Version(1,3,5), ToString(2) returns "1.3" and ToString(4)
+        /// returns "1.3.5.0".
+        /// </returns>
+        public static string ToStringSafe(this Version version, int fieldCount)
+        {
+            return version.EnsureNonNegativeComponents(fieldCount).ToString(fieldCount);
+        }
+    }
+}

src/Nerdbank.GitVersioning.Tasks/GetBuildVersion.cs

@@ -116,8 +116,9 @@ public override bool Execute()
                     ? new Version(typedVersion.Major, typedVersion.Minor, typedVersion.Build)
                     : new Version(typedVersion.Major, typedVersion.Minor);
                 this.SimpleVersion = typedVersionWithoutRevision.ToString();
-                this.MajorMinorVersion = new Version(typedVersion.Major, typedVersion.Minor).ToString();
-                this.AssemblyVersion = versionOptions?.AssemblyVersion?.ToString() ?? this.MajorMinorVersion;
+                var majorMinorVersion = new Version(typedVersion.Major, typedVersion.Minor);
+                this.MajorMinorVersion = majorMinorVersion.ToString();
+                this.AssemblyVersion = (versionOptions?.AssemblyVersion ?? majorMinorVersion).ToStringSafe(4);
                 this.BuildNumber = Math.Max(0, typedVersion.Build);
                 this.Version = typedVersion.ToString();
             }