Allow ignoring part of history when calculating version (issue #538)

docs/configuration.md

@@ -41,6 +41,10 @@ The global configuration options are:
  - **`commits-since-version-source-padding:`** The number of characters to pad `CommitsSinceVersionSource` to in the `CommitsSinceVersionSourcePadded` [variable](/more-info/variables). Is default set to `4`, which will pad the `CommitsSinceVersionSource` value of `1` to `0001`.
 
  - **`commit-message-incrementing:`** Sets whether it should be possible to increment the version with special syntax in the commit message. See the `*-version-bump-message` options above for details on the syntax. Default set to `Enabled`; set to `Disabled` to disable.
+
+ - **`ignore:`** The header for ignore configuration
+   - **`sha:`** A sequence of SHAs to be excluded from the version calculations.  Useful when there is a rogue commit in history yielding a bad version.
+   - **`commits-before:`** Allows to setup an exclusion range.  Effectively any commit < `commits-before` will be ignored.
 
 ## Branch configuration
 

src/GitVersionCore.Tests/ConfigProviderTests.CanWriteOutEffectiveConfiguration.approved.txt

@@ -1,4 +1,4 @@
-assembly-versioning-scheme: MajorMinorPatch
+assembly-versioning-scheme: MajorMinorPatch
 mode: ContinuousDelivery
 tag-prefix: '[vV]'
 continuous-delivery-fallback-tag: ci
@@ -53,3 +53,5 @@ branches:
     increment: Minor
     prevent-increment-of-merged-branch-version: false
     track-merge-target: true
+ignore:
+  sha: []

src/GitVersionCore.Tests/Configuration/IgnoreConfigTests.cs

@@ -0,0 +1,84 @@
+using System;
+using System.IO;
+using GitVersion;
+using NUnit.Framework;
+using Shouldly;
+using YamlDotNet.Core;
+
+namespace GitVersionCore.Tests.Configuration
+{
+    [TestFixture]
+    public class IgnoreConfigTests
+    {
+        [Test]
+        public void CanDeserialize()
+        {
+            var yaml = @"
+ignore:
+    sha: [b6c0c9fda88830ebcd563e500a5a7da5a1658e98]
+    commits-before: 2015-10-23T12:23:15
+";
+
+            using (var reader = new StringReader(yaml))
+            {
+                var config = ConfigSerialiser.Read(reader);
+
+                config.Ignore.ShouldNotBeNull();
+                config.Ignore.SHAs.ShouldNotBeEmpty();
+                config.Ignore.SHAs.ShouldBe(new[] { "b6c0c9fda88830ebcd563e500a5a7da5a1658e98" });
+                config.Ignore.Before.ShouldBe(DateTimeOffset.Parse("2015-10-23T12:23:15"));
+            }
+        }
+
+        [Test]
+        public void ShouldSupportsOtherSequenceFormat()
+        {
+            var yaml = @"
+ignore:
+    sha: 
+        - b6c0c9fda88830ebcd563e500a5a7da5a1658e98
+        - 6c19c7c219ecf8dbc468042baefa73a1b213e8b1
+";
+
+            using (var reader = new StringReader(yaml))
+            {
+                var config = ConfigSerialiser.Read(reader);
+
+                config.Ignore.ShouldNotBeNull();
+                config.Ignore.SHAs.ShouldNotBeEmpty();
+                config.Ignore.SHAs.ShouldBe(new[] { "b6c0c9fda88830ebcd563e500a5a7da5a1658e98", "6c19c7c219ecf8dbc468042baefa73a1b213e8b1" });
+            }
+        }
+
+        [Test]
+        public void WhenNotInConfigShouldHaveDefaults()
+        {
+            var yaml = @"
+next-version: 1.0
+";
+
+            using (var reader = new StringReader(yaml))
+            {
+                var config = ConfigSerialiser.Read(reader);
+
+                config.Ignore.ShouldNotBeNull();
+                config.Ignore.SHAs.ShouldBeEmpty();
+                config.Ignore.Before.ShouldBeNull();
+            }
+        }
+
+        [Test]
+        public void WhenBadDateFormatShouldFail()
+        {
+            var yaml = @"
+ignore:
+    commits-before: bad format date
+";
+
+            using (var reader = new StringReader(yaml))
+            {
+                Should.Throw<YamlException>(() => ConfigSerialiser.Read(reader));
+            }
+        }
+    }
+}

src/GitVersionCore.Tests/GitVersionCore.Tests.csproj

@@ -107,6 +107,7 @@
     <Compile Include="BuildServers\MyGetTests.cs" />
     <Compile Include="BuildServers\VsoAgentTests.cs" />
     <Compile Include="BuildServers\TeamCityTests.cs" />
+    <Compile Include="Configuration\IgnoreConfigTests.cs" />
     <Compile Include="GitToolsTestingExtensions.cs" />
     <Compile Include="DocumentationTests.cs" />
     <Compile Include="ConfigProviderTests.cs" />
@@ -160,6 +161,8 @@
     <Compile Include="VersionCalculation\Strategies\VersionInBranchBaseVersionStrategyTests.cs" />
     <Compile Include="VersionCalculation\TestBaseVersionCalculator.cs" />
     <Compile Include="VersionCalculation\TestMetaDataCalculator.cs" />
+    <Compile Include="VersionFilters\MinDateVersionFilterTests.cs" />
+    <Compile Include="VersionFilters\ShaVersionFilterTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="app.config" />

src/GitVersionCore.Tests/Init/InitScenarios.CanSetNextVersion.approved.txt

@@ -1,2 +1,4 @@
-next-version: 2.0.0
+next-version: 2.0.0
 branches: {}
+ignore:
+  sha: []

src/GitVersionCore.Tests/TestEffectiveConfiguration.cs

@@ -1,14 +1,17 @@
 namespace GitVersionCore.Tests
 {
+    using System.Collections.Generic;
+    using System.Linq;
     using GitVersion;
+    using GitVersion.VersionFilters;
 
     public class TestEffectiveConfiguration : EffectiveConfiguration
     {
         public TestEffectiveConfiguration(
-            AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch, 
+            AssemblyVersioningScheme assemblyVersioningScheme = AssemblyVersioningScheme.MajorMinorPatch,
             string assemblyInformationalFormat = null,
-            VersioningMode versioningMode = VersioningMode.ContinuousDelivery, 
-            string gitTagPrefix = "v", 
+            VersioningMode versioningMode = VersioningMode.ContinuousDelivery,
+            string gitTagPrefix = "v",
             string tag = "",
             string nextVersion = null,
             string branchPrefixToTrim = "",
@@ -22,12 +25,15 @@ public TestEffectiveConfiguration(
             CommitMessageIncrementMode commitMessageMode = CommitMessageIncrementMode.Enabled,
             int legacySemVerPadding = 4,
             int buildMetaDataPadding = 4,
-            int commitsSinceVersionSourcePadding = 4) : 
-                base(assemblyVersioningScheme, assemblyInformationalFormat, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch, 
+            int commitsSinceVersionSourcePadding = 4,
+            IEnumerable<IVersionFilter> versionFilters = null
+            ) :
+            base(assemblyVersioningScheme, assemblyInformationalFormat, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch,
                     branchPrefixToTrim, preventIncrementForMergedBranchVersion, tagNumberPattern, continuousDeploymentFallbackTag,
                     trackMergeTarget,
                     majorMessage, minorMessage, patchMessage,
-                    commitMessageMode, legacySemVerPadding, buildMetaDataPadding, commitsSinceVersionSourcePadding)
+                    commitMessageMode, legacySemVerPadding, buildMetaDataPadding, commitsSinceVersionSourcePadding,
+                    versionFilters ?? Enumerable.Empty<IVersionFilter>())
         {
         }
     }

src/GitVersionCore.Tests/VersionCalculation/BaseVersionCalculatorTests.cs

@@ -6,6 +6,7 @@
     using GitVersion;
     using GitVersion.VersionCalculation;
     using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using GitVersion.VersionFilters;
     using LibGit2Sharp;
     using NUnit.Framework;
     using Shouldly;
@@ -84,5 +85,82 @@ public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
                 yield return new BaseVersion("Source 2", true, new SemanticVersion(2), when, null);
             }
         }
+
+        [Test]
+        public void ShouldNotFilterVersion()
+        {
+            var fakeIgnoreConfig = new TestIgnoreConfig(new ExcludeSourcesContainingExclude());
+            var context = new GitVersionContextBuilder().WithConfig(new Config() { Ignore = fakeIgnoreConfig }).Build();
+            var version = new BaseVersion("dummy", false, new SemanticVersion(2), new MockCommit(), null);
+            var sut = new BaseVersionCalculator(new TestVersionStrategy(version));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.Source.ShouldBe(version.Source);
+            baseVersion.ShouldIncrement.ShouldBe(version.ShouldIncrement);
+            baseVersion.SemanticVersion.ShouldBe(version.SemanticVersion);
+        }
+
+        [Test]
+        public void ShouldFilterVersion()
+        {
+            var fakeIgnoreConfig = new TestIgnoreConfig(new ExcludeSourcesContainingExclude());
+            var context = new GitVersionContextBuilder().WithConfig(new Config() { Ignore = fakeIgnoreConfig }).Build();
+            var higherVersion = new BaseVersion("exclude", false, new SemanticVersion(2), new MockCommit(), null);
+            var lowerVersion = new BaseVersion("dummy", false, new SemanticVersion(1), new MockCommit(), null);
+            var sut = new BaseVersionCalculator(new TestVersionStrategy(higherVersion, lowerVersion));
+
+            var baseVersion = sut.GetBaseVersion(context);
+
+            baseVersion.Source.ShouldNotBe(higherVersion.Source);
+            baseVersion.SemanticVersion.ShouldNotBe(higherVersion.SemanticVersion);
+            baseVersion.Source.ShouldBe(lowerVersion.Source);
+            baseVersion.SemanticVersion.ShouldBe(lowerVersion.SemanticVersion);
+        }
+
+        internal class TestIgnoreConfig : IgnoreConfig
+        {
+            private readonly IVersionFilter filter;
+
+            public TestIgnoreConfig(IVersionFilter filter)
+            {
+                this.filter = filter;
+            }
+
+            public override IEnumerable<IVersionFilter> ToFilters()
+            {
+                yield return filter;
+            }
+        }
+
+        internal class ExcludeSourcesContainingExclude : IVersionFilter
+        {
+            public bool Exclude(BaseVersion version, out string reason)
+            {
+                reason = null;
+
+                if (version.Source.Contains("exclude"))
+                {
+                    reason = "was excluded";
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        class TestVersionStrategy : BaseVersionStrategy
+        {
+            private readonly IEnumerable<BaseVersion> versions;
+
+            public TestVersionStrategy(params BaseVersion[] versions)
+            {
+                this.versions = versions;
+            }
+
+            public override IEnumerable<BaseVersion> GetVersions(GitVersionContext context)
+            {
+                return versions;
+            }
+        }
     }
 }

src/GitVersionCore.Tests/VersionFilters/MinDateVersionFilterTests.cs

@@ -0,0 +1,64 @@
+using System;
+using GitVersion;
+using GitVersion.VersionCalculation.BaseVersionCalculators;
+using GitVersion.VersionFilters;
+using LibGit2Sharp;
+using NUnit.Framework;
+using Shouldly;
+
+namespace GitVersionCore.Tests.VersionFilters
+{
+    [TestFixture]
+    public class MinDateVersionFilterTests
+    {
+        [Test]
+        public void VerifyNullGuard()
+        {
+            var commit = new MockCommit();
+            var dummy = DateTimeOffset.UtcNow.AddSeconds(1.0);
+            var sut = new MinDateVersionFilter(dummy);
+
+            string reason;
+            Should.Throw<ArgumentNullException>(() => sut.Exclude(null, out reason));
+        }
+
+        [Test]
+        public void WhenCommitShouldExcludeWithReason()
+        {
+            var commit = new MockCommit(); //when = UtcNow
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), commit, string.Empty);
+            var futureDate = DateTimeOffset.UtcNow.AddYears(1);
+            var sut = new MinDateVersionFilter(futureDate);
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeTrue();
+            reason.ShouldNotBeNullOrWhiteSpace();
+        }
+
+        [Test]
+        public void WhenShaMismatchShouldNotExclude()
+        {
+            var commit = new MockCommit(); //when = UtcNow
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), commit, string.Empty);
+            var pastDate = DateTimeOffset.UtcNow.AddYears(-1);
+            var sut = new MinDateVersionFilter(pastDate);
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeFalse();
+            reason.ShouldBeNull();
+        }
+
+        [Test]
+        public void ExcludeShouldAcceptVersionWithNullCommit()
+        {
+            Commit nullCommit = null;
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), nullCommit, string.Empty);
+            var futureDate = DateTimeOffset.UtcNow.AddYears(1);
+            var sut = new MinDateVersionFilter(futureDate);
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeFalse();
+            reason.ShouldBeNull();
+        }
+    }
+}

src/GitVersionCore.Tests/VersionFilters/ShaVersionFilterTests.cs

@@ -0,0 +1,66 @@
+using System;
+using GitVersion;
+using GitVersion.VersionCalculation.BaseVersionCalculators;
+using GitVersion.VersionFilters;
+using LibGit2Sharp;
+using NUnit.Framework;
+using Shouldly;
+
+namespace GitVersionCore.Tests.VersionFilters
+{
+    [TestFixture]
+    public class ShaVersionFilterTests
+    {
+        [Test]
+        public void VerifyNullGuard()
+        {
+            Should.Throw<ArgumentNullException>(() => new ShaVersionFilter(null));
+        }
+
+        [Test]
+        public void VerifyNullGuard2()
+        {
+            var commit = new MockCommit();
+            var sut = new ShaVersionFilter(new[] { commit.Sha });
+
+            string reason;
+            Should.Throw<ArgumentNullException>(() => sut.Exclude(null, out reason));
+        }
+
+        [Test]
+        public void WhenShaMatchShouldExcludeWithReason()
+        {
+            var commit = new MockCommit();
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), commit, string.Empty);
+            var sut = new ShaVersionFilter(new[] { commit.Sha });
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeTrue();
+            reason.ShouldNotBeNullOrWhiteSpace();
+        }
+
+        [Test]
+        public void WhenShaMismatchShouldNotExclude()
+        {
+            var commit = new MockCommit();
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), commit, string.Empty);
+            var sut = new ShaVersionFilter(new[] { "mismatched" });
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeFalse();
+            reason.ShouldBeNull();
+        }
+
+        [Test]
+        public void ExcludeShouldAcceptVersionWithNullCommit()
+        {
+            Commit nullCommit = null;
+            var version = new BaseVersion("dummy", false, new SemanticVersion(1), nullCommit, string.Empty);
+            var sut = new ShaVersionFilter(new[] { "mismatched" });
+
+            string reason;
+            sut.Exclude(version, out reason).ShouldBeFalse();
+            reason.ShouldBeNull();
+        }
+    }
+}