Always use commit message increments when present

Author: TomGillen

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

@@ -9,40 +9,68 @@ branches:
     increment: Patch
     prevent-increment-of-merged-branch-version: true
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   release[/-]:
     mode: ContinuousDelivery
     tag: beta
     increment: Patch
     prevent-increment-of-merged-branch-version: true
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   feature[/-]:
     mode: ContinuousDelivery
     tag: useBranchName
     increment: Inherit
     prevent-increment-of-merged-branch-version: false
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   (pull|pull\-requests|pr)[/-]:
     mode: ContinuousDelivery
     tag: PullRequest
     increment: Inherit
     prevent-increment-of-merged-branch-version: false
     tag-number-pattern: '[/-](?<number>\d+)[-/]'
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   hotfix[/-]:
     mode: ContinuousDelivery
     tag: beta
     increment: Patch
     prevent-increment-of-merged-branch-version: false
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   support[/-]:
     mode: ContinuousDelivery
     tag: 
     increment: Patch
     prevent-increment-of-merged-branch-version: true
     track-merge-target: false
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All
   develop:
     mode: ContinuousDeployment
     tag: unstable
     increment: Minor
     prevent-increment-of-merged-branch-version: false
     track-merge-target: true
+    major-version-bump-message: '\+semver:\s?(breaking|major)'
+    minor-version-bump-message: '\+semver:\s?(feature|minor)'
+    patch-version-bump-message: '\+semver:\s?(fix|patch)'
+    commit-message-version-bump-mode: All

src/GitVersionCore.Tests/TestEffectiveConfiguration.cs

@@ -17,11 +17,13 @@ public TestEffectiveConfiguration(
             bool trackMergeTarget = false,
             string majorMessage = null,
             string minorMessage = null,
-            IncrementStrategy messageFallback = IncrementStrategy.Patch) : 
+            string patchMessage = null,
+            CommitMessageVersionMode commitMessageMode = CommitMessageVersionMode.All) : 
                 base(assemblyVersioningScheme, versioningMode, gitTagPrefix, tag, nextVersion, IncrementStrategy.Patch, 
                     branchPrefixToTrim, preventIncrementForMergedBranchVersion, tagNumberPattern, continuousDeploymentFallbackTag,
                     trackMergeTarget,
-                    majorMessage, minorMessage, messageFallback)
+                    majorMessage, minorMessage, patchMessage,
+                    commitMessageMode)
         {
         }
     }

src/GitVersionCore/Configuration/BranchConfig.cs

@@ -16,7 +16,8 @@ public BranchConfig(BranchConfig branchConfiguration)
             PreventIncrementOfMergedBranchVersion = branchConfiguration.PreventIncrementOfMergedBranchVersion;
             TagNumberPattern = branchConfiguration.TagNumberPattern;
             TrackMergeTarget = branchConfiguration.TrackMergeTarget;
-            MessageFallbackStrategy = branchConfiguration.MessageFallbackStrategy;
+            PatchVersionBumpMessage = branchConfiguration.PatchVersionBumpMessage;
+            CommitMessageVersionBumpMode = branchConfiguration.CommitMessageVersionBumpMode;
         }
 
         [YamlMember(Alias = "mode")]
@@ -46,7 +47,10 @@ public BranchConfig(BranchConfig branchConfiguration)
         [YamlMember(Alias = "minor-version-bump-message")]
         public string MinorVersionBumpMessage { get; set; }
 
-        [YamlMember(Alias = "message-fallback")]
-        public IncrementStrategy? MessageFallbackStrategy { get; set; }
+        [YamlMember(Alias = "patch-version-bump-message")]
+        public string PatchVersionBumpMessage { get; set; }
+
+        [YamlMember(Alias = "commit-message-version-bump-mode")]
+        public CommitMessageVersionMode? CommitMessageVersionBumpMode { get; set; }
     }
 }

src/GitVersionCore/Configuration/ConfigurationProvider.cs

@@ -68,14 +68,22 @@ public static void ApplyBranchDefaults(Config config,
             bool defaultPreventIncrement = false,
             VersioningMode? defaultVersioningMode = null, // Looked up from main config
             bool defaultTrackMergeTarget = false,
-            string defaultTagNumberPattern = null)
+            string defaultTagNumberPattern = null,
+            string majorVersionBumpMessage = IncrementStrategyFinder.DefaultMajorPattern,
+            string minorVersionBumpMessage = IncrementStrategyFinder.DefaultMinorPattern,
+            string patchVersionBumpMessage = IncrementStrategyFinder.DefaultPatchPattern,
+            CommitMessageVersionMode commitMessageVersionBump = CommitMessageVersionMode.All)
         {
             branchConfig.Tag = branchConfig.Tag ?? defaultTag;
             branchConfig.TagNumberPattern = branchConfig.TagNumberPattern ?? defaultTagNumberPattern;
             branchConfig.Increment = branchConfig.Increment ?? defaultIncrementStrategy;
             branchConfig.PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion ?? defaultPreventIncrement;
             branchConfig.TrackMergeTarget = branchConfig.TrackMergeTarget ?? defaultTrackMergeTarget;
             branchConfig.VersioningMode = branchConfig.VersioningMode ?? defaultVersioningMode ?? config.VersioningMode;
+            branchConfig.MajorVersionBumpMessage = branchConfig.MajorVersionBumpMessage ?? majorVersionBumpMessage;
+            branchConfig.MinorVersionBumpMessage = branchConfig.MinorVersionBumpMessage ?? minorVersionBumpMessage;
+            branchConfig.PatchVersionBumpMessage = branchConfig.PatchVersionBumpMessage ?? patchVersionBumpMessage;
+            branchConfig.CommitMessageVersionBumpMode = branchConfig.CommitMessageVersionBumpMode ?? commitMessageVersionBump;
         }
 
         static Config ReadConfig(string workingDirectory, IFileSystem fileSystem)

src/GitVersionCore/Configuration/IncrementStrategy.cs

@@ -1,5 +1,7 @@
 namespace GitVersion
 {
+    using System;
+
     public enum IncrementStrategy
     {
         None,
@@ -9,14 +11,26 @@ public enum IncrementStrategy
         /// <summary>
         /// Uses the increment strategy from the branch the current branch was branched from
         /// </summary>
-        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
+        Inherit
+    }
+
+    public static class IncrementStrategyExtensions
+    {
+        public static VersionField ToVersionField(this 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("strategy", strategy, null);
+            }
+        }
     }
 }

src/GitVersionCore/EffectiveConfiguration.cs

@@ -16,7 +16,8 @@ public EffectiveConfiguration(
             bool trackMergeTarget,
             string majorVersionBumpMessage,
             string minorVersionBumpMessage,
-            IncrementStrategy messageFallback)
+            string patchVersionBumpMessage,
+            CommitMessageVersionMode commitMessageVersionBumpMode)
         {
             AssemblyVersioningScheme = assemblyVersioningScheme;
             VersioningMode = versioningMode;
@@ -31,7 +32,8 @@ public EffectiveConfiguration(
             TrackMergeTarget = trackMergeTarget;
             MajorVersionBumpMessage = majorVersionBumpMessage;
             MinorVersionBumpMessage = minorVersionBumpMessage;
-            MessageFallbackStrategy = messageFallback;
+            PatchVersionBumpMessage = patchVersionBumpMessage;
+            CommitMessageVersionBumpMode = commitMessageVersionBumpMode;
         }
 
         public VersioningMode VersioningMode { get; private set; }
@@ -65,7 +67,9 @@ public EffectiveConfiguration(
         public string MajorVersionBumpMessage { get; private set; }
 
         public string MinorVersionBumpMessage { get; private set; }
-        
-        public IncrementStrategy MessageFallbackStrategy { get; private set; }
+
+        public string PatchVersionBumpMessage { get; private set; }
+
+        public CommitMessageVersionMode CommitMessageVersionBumpMode { get; private set; }
     }
 }

src/GitVersionCore/GitVersionContext.cs

@@ -98,20 +98,23 @@ void CalculateEffectiveConfiguration()
             var incrementStrategy = currentBranchConfig.Value.Increment.Value;
             var preventIncrementForMergedBranchVersion = currentBranchConfig.Value.PreventIncrementOfMergedBranchVersion.Value;
             var trackMergeTarget = currentBranchConfig.Value.TrackMergeTarget.Value;
+            var majorMessage = currentBranchConfig.Value.MajorVersionBumpMessage;
+            var minorMessage = currentBranchConfig.Value.MinorVersionBumpMessage;
+            var patchMessage = currentBranchConfig.Value.MinorVersionBumpMessage;
+            var commitMessageVersionBump = currentBranchConfig.Value.CommitMessageVersionBumpMode.Value;
 
             var nextVersion = configuration.NextVersion;
             var assemblyVersioningScheme = configuration.AssemblyVersioningScheme.Value;
             var gitTagPrefix = configuration.TagPrefix;
-            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,
                 trackMergeTarget,
-                majorMessage, minorMessage, messageFallback);
+                majorMessage, minorMessage, patchMessage,
+                commitMessageVersionBump);
         }
     }
 }

src/GitVersionCore/IncrementStrategyFinder.cs

@@ -1,66 +1,83 @@
 namespace GitVersion
 {
-    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Text.RegularExpressions;
     using VersionCalculation.BaseVersionCalculators;
     using LibGit2Sharp;
 
+    public enum CommitMessageVersionMode
+    {
+        All,
+        MergeMessageOnly,
+        None
+    }
+
     public static class IncrementStrategyFinder
     {
-        public static VersionField DetermineIncrementedField(GitVersionContext context, BaseVersion baseVersion)
+        public const string DefaultMajorPattern = @"\+semver:\s?(breaking|major)";
+        public const string DefaultMinorPattern = @"\+semver:\s?(feature|minor)";
+        public const string DefaultPatchPattern = @"\+semver:\s?(fix|patch)";
+
+        public static VersionField? DetermineIncrementedField(GitVersionContext context, BaseVersion baseVersion)
         {
-            if (context.Configuration.Increment != IncrementStrategy.CommitMessage && context.Configuration.Increment != IncrementStrategy.MergeMessage)
+            var commitMessageIncrement = FindCommitMessageIncrement(context, baseVersion);
+            var defaultIncrement = context.Configuration.Increment.ToVersionField();
+
+            // use the default branch config increment strategy if there are no commit message overrides
+            if (commitMessageIncrement == null)
             {
-                return SimpleIncrement(context.Configuration.Increment);
+                return baseVersion.ShouldIncrement ? defaultIncrement : (VersionField?)null;
             }
 
-            var commits = GetIntermediateCommits(context.Repository, baseVersion.BaseVersionSource, context.CurrentCommit);
-
-            if (context.Configuration.Increment == IncrementStrategy.MergeMessage)
+            // cap the commit message severity to minor for alpha versions
+            if (baseVersion.SemanticVersion < new SemanticVersion(1) && commitMessageIncrement > VersionField.Minor)
             {
-                commits = commits.Where(c => c.Parents.Count() > 1);
+                commitMessageIncrement = VersionField.Minor;
             }
 
-            var majorRegex = MajorChangeRegex(context.Configuration.MajorVersionBumpMessage);
-            var minorRegex = MinorChangeRegex(context.Configuration.MinorVersionBumpMessage);
-
-            VersionField biggestField = SimpleIncrement(context.Configuration.MessageFallbackStrategy);
-            foreach (var commit in commits)
+            // don't increment for less than the branch config increment, if the absense of commit messages would have
+            // still resulted in an increment of configuration.Increment
+            if (baseVersion.ShouldIncrement && commitMessageIncrement < defaultIncrement)
             {
-                if (majorRegex.IsMatch(commit.Message))
-                {
-                    biggestField = VersionField.Major;
-                    break;
-                }
-
-                if (biggestField != VersionField.Minor && minorRegex.IsMatch(commit.Message))
-                {
-                    biggestField = VersionField.Minor;
-                }
+                return defaultIncrement;
             }
 
-            return biggestField;
+            return commitMessageIncrement;
         }
 
-        private static VersionField SimpleIncrement(IncrementStrategy strategy)
+        private static VersionField? FindCommitMessageIncrement(GitVersionContext context, BaseVersion baseVersion)
         {
-            switch (strategy)
+            if (context.Configuration.CommitMessageVersionBumpMode == CommitMessageVersionMode.None)
             {
-                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("strategy", strategy, null);
+                return null;
             }
-        }
+            
+            var commits = GetIntermediateCommits(context.Repository, baseVersion.BaseVersionSource, context.CurrentCommit);
 
+            if (context.Configuration.CommitMessageVersionBumpMode == CommitMessageVersionMode.MergeMessageOnly)
+            {
+                commits = commits.Where(c => c.Parents.Count() > 1);
+            }
+
+            var majorRegex = CreateRegex(context.Configuration.MajorVersionBumpMessage ?? DefaultMajorPattern);
+            var minorRegex = CreateRegex(context.Configuration.MinorVersionBumpMessage ?? DefaultMinorPattern);
+            var patchRegex = CreateRegex(context.Configuration.PatchVersionBumpMessage ?? DefaultPatchPattern);
+
+            var increments = commits
+                .Select(c => FindIncrementFromMessage(c.Message, majorRegex, minorRegex, patchRegex))
+                .Where(v => v != null)
+                .Select(v => v.Value)
+                .ToList();
+
+            if (increments.Any())
+            {
+                return increments.Max();
+            }
+
+            return null;
+        }
+        
         private static IEnumerable<Commit> GetIntermediateCommits(IRepository repo, Commit baseCommit, Commit headCommit)
         {
             var filter = new CommitFilter
@@ -73,12 +90,16 @@ private static IEnumerable<Commit> GetIntermediateCommits(IRepository repo, Comm
             return repo.Commits.QueryBy(filter);
         }
 
-        private static Regex MajorChangeRegex(string pattern)
+        private static VersionField? FindIncrementFromMessage(string message, Regex major, Regex minor, Regex patch)
         {
-            return new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
+            if (major.IsMatch(message)) return VersionField.Major;
+            if (minor.IsMatch(message)) return VersionField.Minor;
+            if (patch.IsMatch(message)) return VersionField.Patch;
+
+            return null;
         }
 
-        private static Regex MinorChangeRegex(string pattern)
+        private static Regex CreateRegex(string pattern)
         {
             return new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);
         }

src/GitVersionCore/VersionCalculation/BaseVersionCalculator.cs

@@ -74,10 +74,10 @@ public BaseVersion GetBaseVersion(GitVersionContext context)
 
         static SemanticVersion MaybeIncrement(GitVersionContext context, BaseVersion version)
         {
-            if (version.ShouldIncrement)
+            var increment = IncrementStrategyFinder.DetermineIncrementedField(context, version);
+            if (increment != null)
             {
-                var field = IncrementStrategyFinder.DetermineIncrementedField(context, version);
-                return version.SemanticVersion.IncrementVersion(field);
+                return version.SemanticVersion.IncrementVersion(increment.Value);
             }
 
             return version.SemanticVersion;