Add support for indicating change severity in commit messages

Adds two new increment strategies: CommitMessage and MergeMessage.

While active, the version increment is determined by reading
commit/merge commit messages for markers describing the change severity.

For example, "+semver: breaking" will force a major version bump.

Author: TomGillen

GitVersionCore.Tests/TestEffectiveConfiguration.cs

@@ -14,10 +14,14 @@ public TestEffectiveConfiguration(
             bool preventIncrementForMergedBranchVersion = false,
             string tagNumberPattern = null,
             string continuousDeploymentFallbackTag = "ci",
-            bool trackMergeTarget = false) : 
+            bool trackMergeTarget = false,
+            string majorMessage = null,
+            string minorMessage = null,
+            IncrementStrategy messageFallback = IncrementStrategy.Patch) : 
                 base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch, 
                     branchPrefixToTrim, preventIncrementForMergedBranchVersion, tagNumberPattern, continuousDeploymentFallbackTag,
-                    trackMergeTarget)
+                    trackMergeTarget,
+                    majorMessage, minorMessage, messageFallback)
         {
         }
     }

GitVersionCore/Configuration/BranchConfig.cs

@@ -16,6 +16,7 @@ public BranchConfig(BranchConfig branchConfiguration)
             PreventIncrementOfMergedBranchVersion = branchConfiguration.PreventIncrementOfMergedBranchVersion;
             TagNumberPattern = branchConfiguration.TagNumberPattern;
             TrackMergeTarget = branchConfiguration.TrackMergeTarget;
+            MessageFallbackStrategy = branchConfiguration.MessageFallbackStrategy;
         }
 
         [YamlMember(Alias = "mode")]
@@ -38,5 +39,14 @@ public BranchConfig(BranchConfig branchConfiguration)
 
         [YamlMember(Alias = "track-merge-target")]
         public bool TrackMergeTarget { get; set; }
+
+        [YamlMember(Alias = "major-version-bump-message")]
+        public string MajorVersionBumpMessage { get; set; }
+
+        [YamlMember(Alias = "minor-version-bump-message")]
+        public string MinorVersionBumpMessage { get; set; }
+
+        [YamlMember(Alias = "message-fallback")]
+        public IncrementStrategy? MessageFallbackStrategy { get; set; }
     }
 }

GitVersionCore/Configuration/Config.cs

@@ -18,7 +18,7 @@ public Config()
             Branches["master"] = new BranchConfig
             {
                 Tag = string.Empty,
-                Increment = IncrementStrategy.Patch,
+                Increment = IncrementStrategy.CommitMessage,
                 PreventIncrementOfMergedBranchVersion = true
             };
             Branches["release[/-]"] = new BranchConfig { Tag = "beta" };

GitVersionCore/Configuration/IncrementStrategy.cs

@@ -9,6 +9,14 @@ public enum IncrementStrategy
         /// <summary>
         /// Uses the increment strategy from the branch the current branch was branched from
         /// </summary>
-        Inherit 
+        Inherit,
+        /// <summary>
+        /// Parse commit messages for indications of change severity. If none are found, <c>CommitMessage</c> behaves like <c>Patch</c>.
+        /// </summary>
+        CommitMessage,
+        /// <summary>
+        /// Parse merge commit messages for indications of change severity. If none are found, <c>MergeMessage</c> behaves like <c>Patch</c>.
+        /// </summary>
+        MergeMessage
     }
 }

GitVersionCore/EffectiveConfiguration.cs

@@ -13,7 +13,10 @@ public EffectiveConfiguration(
             bool preventIncrementForMergedBranchVersion, 
             string tagNumberPattern,
             string continuousDeploymentFallbackTag, 
-            bool trackMergeTarget)
+            bool trackMergeTarget,
+            string majorVersionBumpMessage,
+            string minorVersionBumpMessage,
+            IncrementStrategy messageFallback)
         {
             AssemblyVersioningScheme = assemblyVersioningScheme;
             VersioningMode = versioningMode;
@@ -26,6 +29,9 @@ public EffectiveConfiguration(
             TagNumberPattern = tagNumberPattern;
             ContinuousDeploymentFallbackTag = continuousDeploymentFallbackTag;
             TrackMergeTarget = trackMergeTarget;
+            MajorVersionBumpMessage = majorVersionBumpMessage;
+            MinorVersionBumpMessage = minorVersionBumpMessage;
+            MessageFallbackStrategy = messageFallback;
         }
 
         public VersioningMode VersioningMode { get; private set; }
@@ -55,5 +61,11 @@ public EffectiveConfiguration(
         public string ContinuousDeploymentFallbackTag { get; private set; }
 
         public bool TrackMergeTarget { get; private set; }
+
+        public string MajorVersionBumpMessage { get; private set; }
+        
+        public string MinorVersionBumpMessage { get; private set; }
+        
+        public IncrementStrategy MessageFallbackStrategy { get; private set; }
     }
 }

GitVersionCore/GitVersionContext.cs

@@ -86,12 +86,16 @@ void CalculateEffectiveConfiguration()
             var assemblyVersioningScheme = configuration.AssemblyVersioningScheme;
             var gitTagPrefix = configuration.TagPrefix;
             var tagNumberPattern = currentBranchConfig.Value.TagNumberPattern;
+            var majorMessage = currentBranchConfig.Value.MajorVersionBumpMessage ?? @"\+semver:\s?(breaking|major)";
+            var minorMessage = currentBranchConfig.Value.MinorVersionBumpMessage ?? @"\+semver:\s?(feature|minor)";
+            var messageFallback = currentBranchConfig.Value.MessageFallbackStrategy ?? IncrementStrategy.Patch;
             Configuration = new EffectiveConfiguration(
                 assemblyVersioningScheme, versioningMode, gitTagPrefix, 
                 tag, nextVersion, incrementStrategy, currentBranchConfig.Key, 
                 preventIncrementForMergedBranchVersion, 
                 tagNumberPattern, configuration.ContinuousDeploymentFallbackTag,
-                currentBranchConfig.Value.TrackMergeTarget);
+                currentBranchConfig.Value.TrackMergeTarget,
+                majorMessage, minorMessage, messageFallback);
         }
     }
 }

GitVersionCore/GitVersionCore.csproj

@@ -107,6 +107,7 @@
     <Compile Include="Helpers\IFileSystem.cs" />
     <Compile Include="Helpers\ProcessHelper.cs" />
     <Compile Include="Helpers\ServiceMessageEscapeHelper.cs" />
+    <Compile Include="IncrementStrategyFinder.cs" />
     <Compile Include="OutputVariables\VersionVariables.cs" />
     <Compile Include="Extensions\ExtensionMethods.git.cs" />
     <Compile Include="SemanticVersionExtensions.cs" />

GitVersionCore/IncrementStrategyFinder.cs

@@ -0,0 +1,86 @@
+namespace GitVersion
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+    using VersionCalculation.BaseVersionCalculators;
+    using LibGit2Sharp;
+
+    public static class IncrementStrategyFinder
+    {
+        public static VersionField DetermineIncrementedField(GitVersionContext context, BaseVersion baseVersion)
+        {
+            if (context.Configuration.Increment != IncrementStrategy.CommitMessage && context.Configuration.Increment != IncrementStrategy.MergeMessage)
+            {
+                return SimpleIncrement(context.Configuration.Increment);
+            }
+
+            var commits = GetIntermediateCommits(context.Repository, baseVersion.BaseVersionSource, context.CurrentCommit);
+
+            if (context.Configuration.Increment == IncrementStrategy.MergeMessage)
+            {
+                commits = commits.Where(c => c.Parents.Count() > 1);
+            }
+
+            var majorRegex = MajorChangeRegex(context.Configuration.MajorVersionBumpMessage);
+            var minorRegex = MinorChangeRegex(context.Configuration.MinorVersionBumpMessage);
+
+            VersionField biggestField = SimpleIncrement(context.Configuration.MessageFallbackStrategy);
+            foreach (var commit in commits)
+            {
+                if (majorRegex.IsMatch(commit.Message))
+                {
+                    biggestField = VersionField.Major;
+                    break;
+                }
+
+                if (biggestField != VersionField.Minor && minorRegex.IsMatch(commit.Message))
+                {
+                    biggestField = VersionField.Minor;
+                }
+            }
+
+            return biggestField;
+        }
+
+        private static VersionField SimpleIncrement(IncrementStrategy strategy)
+        {
+            switch (strategy)
+            {
+                case IncrementStrategy.None:
+                    return VersionField.None;
+                case IncrementStrategy.Major:
+                    return VersionField.Major;
+                case IncrementStrategy.Minor:
+                    return VersionField.Minor;
+                case IncrementStrategy.Patch:
+                    return VersionField.Patch;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(strategy), strategy, null);
+            }
+        }
+
+        private static IEnumerable<Commit> GetIntermediateCommits(IRepository repo, Commit baseCommit, Commit headCommit)
+        {
+            var filter = new CommitFilter
+            {
+                Since = headCommit,
+                Until = baseCommit,
+                SortBy = CommitSortStrategies.Topological | CommitSortStrategies.Reverse
+            };
+
+            return repo.Commits.QueryBy(filter);
+        }
+
+        private static Regex MajorChangeRegex(string pattern)
+        {
+            return new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
+        }
+
+        private static Regex MinorChangeRegex(string pattern)
+        {
+            return new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
+        }
+    }
+}

GitVersionCore/SemanticVersion.cs

@@ -272,25 +272,25 @@ public string ToString(string format, IFormatProvider formatProvider = null)
             }
         }
 
-        public SemanticVersion IncrementVersion(IncrementStrategy incrementStrategy)
+        public SemanticVersion IncrementVersion(VersionField incrementStrategy)
         {
             var incremented = new SemanticVersion(this);
             if (!incremented.PreReleaseTag.HasTag())
             {
                 switch (incrementStrategy)
                 {
-                    case IncrementStrategy.None:
+                    case VersionField.None:
                         break;
-                    case IncrementStrategy.Major:
+                    case VersionField.Major:
                         incremented.Major++;
                         incremented.Minor = 0;
                         incremented.Patch = 0;
                         break;
-                    case IncrementStrategy.Minor:
+                    case VersionField.Minor:
                         incremented.Minor++;
                         incremented.Patch = 0;
                         break;
-                    case IncrementStrategy.Patch:
+                    case VersionField.Patch:
                         incremented.Patch++;
                         break;
                     default:
@@ -309,4 +309,12 @@ public SemanticVersion IncrementVersion(IncrementStrategy incrementStrategy)
             return incremented;
         }
     }
+
+    public enum VersionField
+    {
+        None,
+        Patch,
+        Minor,
+        Major
+    }
 }

GitVersionCore/VersionCalculation/BaseVersionCalculator.cs

@@ -70,7 +70,13 @@ public BaseVersion GetBaseVersion(GitVersionContext context)
 
         static SemanticVersion MaybeIncrement(GitVersionContext context, BaseVersion version)
         {
-            return version.ShouldIncrement ? version.SemanticVersion.IncrementVersion(context.Configuration.Increment) : version.SemanticVersion;
+            if (version.ShouldIncrement)
+            {
+                var field = IncrementStrategyFinder.DetermineIncrementedField(context, version);
+                return version.SemanticVersion.IncrementVersion(field);
+            }
+
+            return version.SemanticVersion;
         }
     }
 }

GitVersionCore/VersionCalculation/NextVersionCalculator.cs

@@ -40,7 +40,8 @@ public SemanticVersion FindVersion(GitVersionContext context)
             var semver = baseVersion.SemanticVersion;
             if (baseVersion.ShouldIncrement)
             {
-                semver = semver.IncrementVersion(context.Configuration.Increment);
+                var field = IncrementStrategyFinder.DetermineIncrementedField(context, baseVersion);
+                semver = semver.IncrementVersion(field);
             }
             else Logger.WriteInfo("Skipping version increment");