Merge pull request #1342 from JakeGinnivan/fix/release-issues

JakeGinnivan · web-flow · commit e4cd2eaf4f34 · 2017-12-09T18:10:40.000+08:00
Fix/release issues
diff --git a/build.cake b/build.cake
@@ -47,6 +47,7 @@ void Build(string configuration, string nugetVersion, string semVersion, string
     }
 }
 
+// This build task can be run to just build
 Task("DogfoodBuild")
     .IsDependentOn("NuGet-Package-Restore")
     .Does(() =>
@@ -92,7 +93,7 @@ Task("Build")
 });
 
 Task("Run-NUnit-Tests")
-    .IsDependentOn("Build")
+    .IsDependentOn("DogfoodBuild")
     .Does(() =>
 {
     var settings = new NUnit3Settings();
@@ -113,6 +114,7 @@ Task("Run-NUnit-Tests")
 });
 
 Task("Zip-Files")
+    .IsDependentOn("Build")
     .IsDependentOn("Run-NUnit-Tests")
     .Does(() =>
 {
diff --git a/src/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs b/src/GitVersionCore.Tests/VersionCalculation/Strategies/MergeMessageBaseVersionStrategyTests.cs
@@ -58,6 +58,7 @@ public void ShouldNotAllowIncrementOfVersion()
         [TestCase("Finish 0.14.1", true, "0.14.1")] //Support Syntevo SmartGit/Hg's Gitflow merge commit messages for finishing a 'Hotfix' branch
         [TestCase("Merge branch 'Release-v0.2.0'", true, "0.2.0")]
         [TestCase("Merge branch 'Release-v2.2'", true, "2.2.0")]
+        [TestCase("Merge remote-tracking branch 'origin/release/0.8.0' into develop/master", true, "0.8.0")]
         public void AssertMergeMessage(string message, bool isMergeCommit, string expectedVersion)
         {
             var parents = GetParents(isMergeCommit);
@@ -121,6 +122,7 @@ static void AssertMergeMessage(string message, string expectedVersion, List<Comm
             }
             else
             {
+                baseVersion.ShouldNotBeNull();
                 baseVersion.SemanticVersion.ToString().ShouldBe(expectedVersion);
             }
         }
diff --git a/src/GitVersionCore/BranchConfigurationCalculator.cs b/src/GitVersionCore/BranchConfigurationCalculator.cs
@@ -15,7 +15,7 @@ public class BranchConfigurationCalculator
         /// </summary>
         public static BranchConfig GetBranchConfiguration(GitVersionContext context, Branch targetBranch, IList<Branch> excludedInheritBranches = null)
         {
-            var matchingBranches = context.FullConfiguration.GetConfigForBranch(targetBranch.FriendlyName);
+            var matchingBranches = context.FullConfiguration.GetConfigForBranch(targetBranch.NameWithoutRemote());
             
             if (matchingBranches == null)
             {
@@ -27,11 +27,20 @@ public static BranchConfig GetBranchConfiguration(GitVersionContext context, Bra
                 ConfigurationProvider.ApplyBranchDefaults(context.FullConfiguration, matchingBranches, "", new List<string>());
             }
 
-            return matchingBranches.Increment == IncrementStrategy.Inherit ?
-                InheritBranchConfiguration(context, targetBranch, matchingBranches, excludedInheritBranches) :
-                matchingBranches;
+            if (matchingBranches.Increment == IncrementStrategy.Inherit)
+            {
+                matchingBranches = InheritBranchConfiguration(context, targetBranch, matchingBranches, excludedInheritBranches);
+                if (matchingBranches.Name == FallbackConfigName && matchingBranches.Increment == IncrementStrategy.Inherit)
+                {
+                    // We tried, and failed to inherit, just fall back to patch
+                    matchingBranches.Increment = IncrementStrategy.Patch;
+                }
+            }
+
+            return matchingBranches;
         }
 
+        // TODO I think we need to take a fresh approach to this.. it's getting really complex with heaps of edge cases
         static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch targetBranch, BranchConfig branchConfiguration, IList<Branch> excludedInheritBranches)
         {
             var repository = context.Repository;
@@ -50,17 +59,17 @@ static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch
                 {
                     excludedInheritBranches = repository.Branches.Where(b =>
                     {
-                        var branchConfig = config.GetConfigForBranch(b.FriendlyName);
+                        var branchConfig = config.GetConfigForBranch(b.NameWithoutRemote());
 
-                        return branchConfig != null && branchConfig.Increment == IncrementStrategy.Inherit;
+                        return branchConfig == null || branchConfig.Increment == IncrementStrategy.Inherit;
                     }).ToList();
                 }
                 // Add new excluded branches.
                 foreach (var excludedBranch in excludedBranches.ExcludingBranches(excludedInheritBranches))
                 {
                     excludedInheritBranches.Add(excludedBranch);
                 }
-                var branchesToEvaluate = repository.Branches.Except(excludedInheritBranches).ToList();
+                var branchesToEvaluate = repository.Branches.ExcludingBranches(excludedInheritBranches).ToList();
 
                 var branchPoint = context.RepositoryMetadataProvider
                     .FindCommitBranchWasBranchedFrom(targetBranch, excludedInheritBranches.ToArray());
@@ -94,13 +103,17 @@ static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch
                 if (possibleParents.Count == 1)
                 {
                     var branchConfig = GetBranchConfiguration(context, possibleParents[0], excludedInheritBranches);
-                    return new BranchConfig(branchConfiguration)
+                    // If we have resolved a fallback config we should not return that we have got config
+                    if (branchConfig.Name != FallbackConfigName)
                     {
-                        Increment = branchConfig.Increment,
-                        PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,
-                        // If we are inheriting from develop then we should behave like develop
-                        TracksReleaseBranches = branchConfig.TracksReleaseBranches
-                    };
+                        return new BranchConfig(branchConfiguration)
+                        {
+                            Increment = branchConfig.Increment,
+                            PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,
+                            // If we are inheriting from develop then we should behave like develop
+                            TracksReleaseBranches = branchConfig.TracksReleaseBranches
+                        };
+                    }
                 }
 
                 // If we fail to inherit it is probably because the branch has been merged and we can't do much. So we will fall back to develop's config
diff --git a/src/GitVersionCore/GitRepoMetadataProvider.cs b/src/GitVersionCore/GitRepoMetadataProvider.cs
@@ -198,8 +198,7 @@ public BranchCommit FindCommitBranchWasBranchedFrom(Branch branch, params Branch
                     return BranchCommit.Empty;
                 }
 
-                var possibleBranches = GetMergeCommitsForBranch(branch)
-                    .ExcludingBranches(excludedBranches)
+                var possibleBranches = GetMergeCommitsForBranch(branch, excludedBranches)
                     .Where(b => !branch.IsSameBranch(b.Branch))
                     .ToList();
 
@@ -216,7 +215,7 @@ public BranchCommit FindCommitBranchWasBranchedFrom(Branch branch, params Branch
             }
         }
 
-        List<BranchCommit> GetMergeCommitsForBranch(Branch branch)
+        List<BranchCommit> GetMergeCommitsForBranch(Branch branch, Branch[] excludedBranches)
         {
             if (mergeBaseCommitsCache.ContainsKey(branch))
             {
@@ -226,11 +225,12 @@ List<BranchCommit> GetMergeCommitsForBranch(Branch branch)
                 return mergeBaseCommitsCache[branch];
             }
 
-            var currentBranchConfig = configuration.GetConfigForBranch(branch.FriendlyName);
+            var currentBranchConfig = configuration.GetConfigForBranch(branch.NameWithoutRemote());
             var regexesToCheck = currentBranchConfig == null
                 ? new [] { ".*" } // Match anything if we can't find a branch config
                 : currentBranchConfig.SourceBranches.Select(sb => configuration.Branches[sb].Regex);
             var branchMergeBases = Repository.Branches
+                .ExcludingBranches(excludedBranches)
                 .Where(b =>
                 {
                     if (b == branch) return false;
diff --git a/src/GitVersionCore/IncrementStrategyFinder.cs b/src/GitVersionCore/IncrementStrategyFinder.cs
@@ -129,7 +129,7 @@ private static Regex CreateRegex(string pattern)
 
         public static VersionField FindDefaultIncrementForBranch( GitVersionContext context, string branch = null )
         {
-            var config = context.FullConfiguration.GetConfigForBranch(branch ?? context.CurrentBranch.FriendlyName);
+            var config = context.FullConfiguration.GetConfigForBranch(branch ?? context.CurrentBranch.NameWithoutRemote());
             if ( config?.Increment != null && config.Increment != IncrementStrategy.Inherit )
             {
                 return config.Increment.Value.ToVersionField();
diff --git a/src/GitVersionCore/LibGitExtensions.cs b/src/GitVersionCore/LibGitExtensions.cs
@@ -17,15 +17,21 @@ public static DateTimeOffset When(this Commit commit)
         /// <summary>
         /// Checks if the two branch objects refer to the same branch (have the same friendly name).
         /// </summary>
-        public static bool IsSameBranch(this Branch branch, Branch otherBranch)
+        public static string NameWithoutRemote(this Branch branch)
         {
-            // For each branch, fixup the friendly name if the branch is remote.
-            var otherBranchFriendlyName = otherBranch.IsRemote ?
-                otherBranch.FriendlyName.Substring(otherBranch.FriendlyName.IndexOf("/", StringComparison.Ordinal) + 1) :
-                otherBranch.FriendlyName;
-            var branchFriendlyName = branch.IsRemote ?
+            return branch.IsRemote ?
                 branch.FriendlyName.Substring(branch.FriendlyName.IndexOf("/", StringComparison.Ordinal) + 1) :
                 branch.FriendlyName;
+        }
+
+        /// <summary>
+        /// Checks if the two branch objects refer to the same branch (have the same friendly name).
+        /// </summary>
+        public static bool IsSameBranch(this Branch branch, Branch otherBranch)
+        {
+            // For each branch, fixup the friendly name if the branch is remote.
+            var otherBranchFriendlyName = otherBranch.NameWithoutRemote();
+            var branchFriendlyName = branch.NameWithoutRemote();
 
             return otherBranchFriendlyName == branchFriendlyName;
         }
diff --git a/src/GitVersionCore/MergeMessage.cs b/src/GitVersionCore/MergeMessage.cs
@@ -15,6 +15,10 @@ class MergeMessage
         static Regex smartGitMergeMessage = new Regex(
             @"^Finish (?<Branch>.*)",
             RegexOptions.IgnoreCase | RegexOptions.Compiled);
+        static Regex parseRemoteTrackingMergeMessage = new Regex(
+            @"^Merge remote-tracking branch '(?<SourceBranch>.*)' into (?<TargetBranch>.*)",
+            RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
         private string mergeMessage;
         private Config config;
 
@@ -73,7 +77,14 @@ private string ParseBranch()
                     PullRequestNumber = pullNumber;
                 }
                 var from = match.Groups["Source"].Value;
-                // We could remove/separate the remote name at this point?
+                // TODO We could remove/separate the remote name at this point?
+                return from;
+            }
+
+            match = parseRemoteTrackingMergeMessage.Match(mergeMessage);
+            if (match.Success) {
+                var from = match.Groups["SourceBranch"].Value;
+                // TODO We could remove/separate the remote name at this point?
                 return from;
             }
 

Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,7 @@ void Build(string configuration, string nugetVersion, string semVersion, string`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
	`50`	`+// This build task can be run to just build`
`50`	`51`	`Task("DogfoodBuild")`
`51`	`52`	`.IsDependentOn("NuGet-Package-Restore")`
`52`	`53`	`.Does(() =>`
`@@ -92,7 +93,7 @@ Task("Build")`
`92`	`93`	`});`
`93`	`94`
`94`	`95`	`Task("Run-NUnit-Tests")`
`95`		`- .IsDependentOn("Build")`
	`96`	`+ .IsDependentOn("DogfoodBuild")`
`96`	`97`	`.Does(() =>`
`97`	`98`	`{`
`98`	`99`	`var settings = new NUnit3Settings();`
`@@ -113,6 +114,7 @@ Task("Run-NUnit-Tests")`
`113`	`114`	`});`
`114`	`115`
`115`	`116`	`Task("Zip-Files")`
	`117`	`+ .IsDependentOn("Build")`
`116`	`118`	`.IsDependentOn("Run-NUnit-Tests")`
`117`	`119`	`.Does(() =>`
`118`	`120`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,7 @@ public void ShouldNotAllowIncrementOfVersion()`
`58`	`58`	`[TestCase("Finish 0.14.1", true, "0.14.1")] //Support Syntevo SmartGit/Hg's Gitflow merge commit messages for finishing a 'Hotfix' branch`
`59`	`59`	`[TestCase("Merge branch 'Release-v0.2.0'", true, "0.2.0")]`
`60`	`60`	`[TestCase("Merge branch 'Release-v2.2'", true, "2.2.0")]`
	`61`	`+ [TestCase("Merge remote-tracking branch 'origin/release/0.8.0' into develop/master", true, "0.8.0")]`
`61`	`62`	`public void AssertMergeMessage(string message, bool isMergeCommit, string expectedVersion)`
`62`	`63`	`{`
`63`	`64`	`var parents = GetParents(isMergeCommit);`
`@@ -121,6 +122,7 @@ static void AssertMergeMessage(string message, string expectedVersion, List<Comm`
`121`	`122`	`}`
`122`	`123`	`else`
`123`	`124`	`{`
	`125`	`+ baseVersion.ShouldNotBeNull();`
`124`	`126`	`baseVersion.SemanticVersion.ToString().ShouldBe(expectedVersion);`
`125`	`127`	`}`
`126`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class BranchConfigurationCalculator`
`15`	`15`	`/// </summary>`
`16`	`16`	`public static BranchConfig GetBranchConfiguration(GitVersionContext context, Branch targetBranch, IList<Branch> excludedInheritBranches = null)`
`17`	`17`	`{`
`18`		`- var matchingBranches = context.FullConfiguration.GetConfigForBranch(targetBranch.FriendlyName);`
	`18`	`+ var matchingBranches = context.FullConfiguration.GetConfigForBranch(targetBranch.NameWithoutRemote());`
`19`	`19`
`20`	`20`	`if (matchingBranches == null)`
`21`	`21`	`{`
`@@ -27,11 +27,20 @@ public static BranchConfig GetBranchConfiguration(GitVersionContext context, Bra`
`27`	`27`	`ConfigurationProvider.ApplyBranchDefaults(context.FullConfiguration, matchingBranches, "", new List<string>());`
`28`	`28`	`}`
`29`	`29`
`30`		`- return matchingBranches.Increment == IncrementStrategy.Inherit ?`
`31`		`- InheritBranchConfiguration(context, targetBranch, matchingBranches, excludedInheritBranches) :`
`32`		`- matchingBranches;`
	`30`	`+ if (matchingBranches.Increment == IncrementStrategy.Inherit)`
	`31`	`+ {`
	`32`	`+ matchingBranches = InheritBranchConfiguration(context, targetBranch, matchingBranches, excludedInheritBranches);`
	`33`	`+ if (matchingBranches.Name == FallbackConfigName && matchingBranches.Increment == IncrementStrategy.Inherit)`
	`34`	`+ {`
	`35`	`+ // We tried, and failed to inherit, just fall back to patch`
	`36`	`+ matchingBranches.Increment = IncrementStrategy.Patch;`
	`37`	`+ }`
	`38`	`+ }`
	`39`	`+`
	`40`	`+ return matchingBranches;`
`33`	`41`	`}`
`34`	`42`
	`43`	`+ // TODO I think we need to take a fresh approach to this.. it's getting really complex with heaps of edge cases`
`35`	`44`	`static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch targetBranch, BranchConfig branchConfiguration, IList<Branch> excludedInheritBranches)`
`36`	`45`	`{`
`37`	`46`	`var repository = context.Repository;`
`@@ -50,17 +59,17 @@ static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch`
`50`	`59`	`{`
`51`	`60`	`excludedInheritBranches = repository.Branches.Where(b =>`
`52`	`61`	`{`
`53`		`- var branchConfig = config.GetConfigForBranch(b.FriendlyName);`
	`62`	`+ var branchConfig = config.GetConfigForBranch(b.NameWithoutRemote());`
`54`	`63`
`55`		`- return branchConfig != null && branchConfig.Increment == IncrementStrategy.Inherit;`
	`64`	`+ return branchConfig == null \|\| branchConfig.Increment == IncrementStrategy.Inherit;`
`56`	`65`	`}).ToList();`
`57`	`66`	`}`
`58`	`67`	`// Add new excluded branches.`
`59`	`68`	`foreach (var excludedBranch in excludedBranches.ExcludingBranches(excludedInheritBranches))`
`60`	`69`	`{`
`61`	`70`	`excludedInheritBranches.Add(excludedBranch);`
`62`	`71`	`}`
`63`		`- var branchesToEvaluate = repository.Branches.Except(excludedInheritBranches).ToList();`
	`72`	`+ var branchesToEvaluate = repository.Branches.ExcludingBranches(excludedInheritBranches).ToList();`
`64`	`73`
`65`	`74`	`var branchPoint = context.RepositoryMetadataProvider`
`66`	`75`	`.FindCommitBranchWasBranchedFrom(targetBranch, excludedInheritBranches.ToArray());`
`@@ -94,13 +103,17 @@ static BranchConfig InheritBranchConfiguration(GitVersionContext context, Branch`
`94`	`103`	`if (possibleParents.Count == 1)`
`95`	`104`	`{`
`96`	`105`	`var branchConfig = GetBranchConfiguration(context, possibleParents[0], excludedInheritBranches);`
`97`		`- return new BranchConfig(branchConfiguration)`
	`106`	`+ // If we have resolved a fallback config we should not return that we have got config`
	`107`	`+ if (branchConfig.Name != FallbackConfigName)`
`98`	`108`	`{`
`99`		`- Increment = branchConfig.Increment,`
`100`		`- PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,`
`101`		`- // If we are inheriting from develop then we should behave like develop`
`102`		`- TracksReleaseBranches = branchConfig.TracksReleaseBranches`
`103`		`- };`
	`109`	`+ return new BranchConfig(branchConfiguration)`
	`110`	`+ {`
	`111`	`+ Increment = branchConfig.Increment,`
	`112`	`+ PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,`
	`113`	`+ // If we are inheriting from develop then we should behave like develop`
	`114`	`+ TracksReleaseBranches = branchConfig.TracksReleaseBranches`
	`115`	`+ };`
	`116`	`+ }`
`104`	`117`	`}`
`105`	`118`
`106`	`119`	`// If we fail to inherit it is probably because the branch has been merged and we can't do much. So we will fall back to develop's config`
Original file line number	Diff line number	Diff line change
`@@ -198,8 +198,7 @@ public BranchCommit FindCommitBranchWasBranchedFrom(Branch branch, params Branch`
`198`	`198`	`return BranchCommit.Empty;`
`199`	`199`	`}`
`200`	`200`
`201`		`- var possibleBranches = GetMergeCommitsForBranch(branch)`
`202`		`- .ExcludingBranches(excludedBranches)`
	`201`	`+ var possibleBranches = GetMergeCommitsForBranch(branch, excludedBranches)`
`203`	`202`	`.Where(b => !branch.IsSameBranch(b.Branch))`
`204`	`203`	`.ToList();`
`205`	`204`
`@@ -216,7 +215,7 @@ public BranchCommit FindCommitBranchWasBranchedFrom(Branch branch, params Branch`
`216`	`215`	`}`
`217`	`216`	`}`
`218`	`217`
`219`		`- List<BranchCommit> GetMergeCommitsForBranch(Branch branch)`
	`218`	`+ List<BranchCommit> GetMergeCommitsForBranch(Branch branch, Branch[] excludedBranches)`
`220`	`219`	`{`
`221`	`220`	`if (mergeBaseCommitsCache.ContainsKey(branch))`
`222`	`221`	`{`
`@@ -226,11 +225,12 @@ List<BranchCommit> GetMergeCommitsForBranch(Branch branch)`
`226`	`225`	`return mergeBaseCommitsCache[branch];`
`227`	`226`	`}`
`228`	`227`
`229`		`- var currentBranchConfig = configuration.GetConfigForBranch(branch.FriendlyName);`
	`228`	`+ var currentBranchConfig = configuration.GetConfigForBranch(branch.NameWithoutRemote());`
`230`	`229`	`var regexesToCheck = currentBranchConfig == null`
`231`	`230`	`? new [] { ".*" } // Match anything if we can't find a branch config`
`232`	`231`	`: currentBranchConfig.SourceBranches.Select(sb => configuration.Branches[sb].Regex);`
`233`	`232`	`var branchMergeBases = Repository.Branches`
	`233`	`+ .ExcludingBranches(excludedBranches)`
`234`	`234`	`.Where(b =>`
`235`	`235`	`{`
`236`	`236`	`if (b == branch) return false;`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ private static Regex CreateRegex(string pattern)`
`129`	`129`
`130`	`130`	`public static VersionField FindDefaultIncrementForBranch( GitVersionContext context, string branch = null )`
`131`	`131`	`{`
`132`		`- var config = context.FullConfiguration.GetConfigForBranch(branch ?? context.CurrentBranch.FriendlyName);`
	`132`	`+ var config = context.FullConfiguration.GetConfigForBranch(branch ?? context.CurrentBranch.NameWithoutRemote());`
`133`	`133`	`if ( config?.Increment != null && config.Increment != IncrementStrategy.Inherit )`
`134`	`134`	`{`
`135`	`135`	`return config.Increment.Value.ToVersionField();`