Put the name of the branch configuration in BranchConfig.

DanielRose · JakeGinnivan · commit cb77f9769805 · 2016-11-26T19:48:07.000+08:00
diff --git a/src/GitVersionCore.Tests/IntegrationTests/FeatureBranchScenarios.cs b/src/GitVersionCore.Tests/IntegrationTests/FeatureBranchScenarios.cs
@@ -4,7 +4,6 @@
 using GitVersionCore.Tests;
 using LibGit2Sharp;
 using NUnit.Framework;
-using System.Collections.Generic;
 
 [TestFixture]
 public class FeatureBranchScenarios
@@ -296,7 +295,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchCreated()
                     {
                         "master", new BranchConfig()
                         {
-                            IsDevelop = true,
+                            TracksReleaseBranches = true,
                             Regex = "master"
                         }
                     }
@@ -329,7 +328,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchMergedBack()
                     {
                         "master", new BranchConfig()
                         {
-                            IsDevelop = true,
+                            TracksReleaseBranches = true,
                             Regex = "master"
                         }
                     }
@@ -414,7 +413,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchCreated()
                         {
                             "master", new BranchConfig()
                             {
-                                IsDevelop = true,
+                                TracksReleaseBranches = true,
                                 Regex = "master"
                             }
                         }
@@ -447,7 +446,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchMergedBack()
                         {
                             "master", new BranchConfig()
                             {
-                                IsDevelop = true,
+                                TracksReleaseBranches = true,
                                 Regex = "master"
                             }
                         }
diff --git a/src/GitVersionCore/BranchConfigurationCalculator.cs b/src/GitVersionCore/BranchConfigurationCalculator.cs
@@ -9,38 +9,41 @@ namespace GitVersion
 
     public class BranchConfigurationCalculator
     {
-        public static KeyValuePair<string, BranchConfig> GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)
+        /// <summary>
+        /// Gets the <see cref="BranchConfig"/> for the current commit.
+        /// </summary>
+        public static BranchConfig GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)
         {
-            var matchingBranches = LookupBranchConfiguration(config, currentBranch);
+            var matchingBranches = LookupBranchConfiguration(config, currentBranch).ToArray();
 
             if (matchingBranches.Length == 0)
             {
                 Logger.WriteInfo(string.Format(
                     "No branch configuration found for branch {0}, falling back to default configuration",
                     currentBranch.FriendlyName));
 
-                var branchConfig = new BranchConfig();
+                var branchConfig = new BranchConfig { Name = string.Empty };
                 ConfigurationProvider.ApplyBranchDefaults(config, branchConfig, "");
-                return new KeyValuePair<string, BranchConfig>(string.Empty, branchConfig);
+                return branchConfig;
             }
+
             if (matchingBranches.Length == 1)
             {
-                var keyValuePair = matchingBranches[0];
-                var branchConfiguration = keyValuePair.Value;
+                var branchConfiguration = matchingBranches[0];
 
                 if (branchConfiguration.Increment == IncrementStrategy.Inherit)
                 {
-                    return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, keyValuePair, branchConfiguration, config, excludedInheritBranches);
+                    return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, branchConfiguration, config, excludedInheritBranches);
                 }
 
-                return keyValuePair;
+                return branchConfiguration;
             }
 
             const string format = "Multiple branch configurations match the current branch branchName of '{0}'. Matching configurations: '{1}'";
-            throw new Exception(string.Format(format, currentBranch.FriendlyName, string.Join(", ", matchingBranches.Select(b => b.Key))));
+            throw new Exception(string.Format(format, currentBranch.FriendlyName, string.Join(", ", matchingBranches.Select(b => b.Name))));
         }
 
-        static KeyValuePair<string, BranchConfig>[] LookupBranchConfiguration([NotNull] Config config, [NotNull] Branch currentBranch)
+        static IEnumerable<BranchConfig> LookupBranchConfiguration([NotNull] Config config, [NotNull] Branch currentBranch)
         {
             if (config == null)
             {
@@ -52,11 +55,11 @@ static KeyValuePair<string, BranchConfig>[] LookupBranchConfiguration([NotNull]
                 throw new ArgumentNullException("currentBranch");
             }
 
-            return config.Branches.Where(b => Regex.IsMatch(currentBranch.FriendlyName, "^" + b.Value.Regex, RegexOptions.IgnoreCase)).ToArray();
+            return config.Branches.Where(b => Regex.IsMatch(currentBranch.FriendlyName, "^" + b.Value.Regex, RegexOptions.IgnoreCase)).Select(kvp => kvp.Value);
         }
 
 
-        static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEvaluateTrackedBranches, IRepository repository, Commit currentCommit, Branch currentBranch, KeyValuePair<string, BranchConfig> keyValuePair, BranchConfig branchConfiguration, Config config, IList<Branch> excludedInheritBranches)
+        static BranchConfig InheritBranchConfiguration(bool onlyEvaluateTrackedBranches, IRepository repository, Commit currentCommit, Branch currentBranch, BranchConfig branchConfiguration, Config config, IList<Branch> excludedInheritBranches)
         {
             using (Logger.IndentLog("Attempting to inherit branch configuration from parent branch"))
             {
@@ -72,11 +75,11 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv
                 {
                     excludedInheritBranches = repository.Branches.Where(b =>
                     {
-                        var branchConfig = LookupBranchConfiguration(config, b);
+                        var branchConfig = LookupBranchConfiguration(config, b).ToArray();
 
                         // NOTE: if length is 0 we couldn't find the configuration for the branch e.g. "origin/master"
                         // NOTE: if the length is greater than 1 we cannot decide which merge strategy to pick
-                        return (branchConfig.Length != 1) || (branchConfig.Length == 1 && branchConfig[0].Value.Increment == IncrementStrategy.Inherit);
+                        return (branchConfig.Length != 1) || (branchConfig.Length == 1 && branchConfig[0].Increment == IncrementStrategy.Inherit);
                     }).ToList();
                 }
                 excludedBranches.ToList().ForEach(excludedInheritBranches.Add);
@@ -110,16 +113,14 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv
 
                 if (possibleParents.Count == 1)
                 {
-                    var branchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, possibleParents[0], excludedInheritBranches).Value;
-                    return new KeyValuePair<string, BranchConfig>(
-                        keyValuePair.Key,
-                        new BranchConfig(branchConfiguration)
-                        {
-                            Increment = branchConfig.Increment,
-                            PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,
-                            // If we are inheriting from develop then we should behave like develop
-                            TracksReleaseBranches = branchConfig.TracksReleaseBranches
-                        });
+                    var branchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, possibleParents[0], excludedInheritBranches);
+                    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
@@ -142,16 +143,14 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv
                 var branchName = chosenBranch.FriendlyName;
                 Logger.WriteWarning(errorMessage + Environment.NewLine + Environment.NewLine + "Falling back to " + branchName + " branch config");
 
-                var inheritingBranchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, chosenBranch).Value;
-                return new KeyValuePair<string, BranchConfig>(
-                    keyValuePair.Key,
-                    new BranchConfig(branchConfiguration)
-                    {
-                        Increment = inheritingBranchConfig.Increment,
-                        PreventIncrementOfMergedBranchVersion = inheritingBranchConfig.PreventIncrementOfMergedBranchVersion,
-                        // If we are inheriting from develop then we should behave like develop
-                        TracksReleaseBranches = inheritingBranchConfig.TracksReleaseBranches
-                    });
+                var inheritingBranchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, chosenBranch);
+                return new BranchConfig(branchConfiguration)
+                {
+                    Increment = inheritingBranchConfig.Increment,
+                    PreventIncrementOfMergedBranchVersion = inheritingBranchConfig.PreventIncrementOfMergedBranchVersion,
+                    // If we are inheriting from develop then we should behave like develop
+                    TracksReleaseBranches = inheritingBranchConfig.TracksReleaseBranches
+                };
             }
         }
 
diff --git a/src/GitVersionCore/Configuration/BranchConfig.cs b/src/GitVersionCore/Configuration/BranchConfig.cs
@@ -24,6 +24,7 @@ public BranchConfig(BranchConfig branchConfiguration)
             Regex = branchConfiguration.Regex;
             IsReleaseBranch = branchConfiguration.IsReleaseBranch;
             IsMainline = branchConfiguration.IsMainline;
+            Name = branchConfiguration.Name;
         }
 
         [YamlMember(Alias = "mode")]
@@ -61,5 +62,11 @@ public BranchConfig(BranchConfig branchConfiguration)
 
         [YamlMember(Alias = "is-mainline")]
         public bool? IsMainline { get; set; }
+
+        /// <summary>
+        /// The name given to this configuration in the config file.
+        /// </summary>
+        [YamlIgnore]
+        public string Name { get; set; }
     }
 }
diff --git a/src/GitVersionCore/Configuration/Config.cs b/src/GitVersionCore/Configuration/Config.cs
@@ -79,7 +79,7 @@ public Dictionary<string, BranchConfig> Branches
                 value.ToList().ForEach(_ =>
                 {
                     if (!branches.ContainsKey(_.Key))
-                        branches.Add(_.Key, new BranchConfig());
+                        branches.Add(_.Key, new BranchConfig {Name = _.Key});
 
                     branches[_.Key] = MergeObjects(branches[_.Key], _.Value);
                 });
diff --git a/src/GitVersionCore/Configuration/ConfigurationProvider.cs b/src/GitVersionCore/Configuration/ConfigurationProvider.cs
@@ -147,7 +147,7 @@ static BranchConfig GetOrCreateBranchDefaults(Config config, string branchKey)
         {
             if (!config.Branches.ContainsKey(branchKey))
             {
-                var branchConfig = new BranchConfig();
+                var branchConfig = new BranchConfig {Name = branchKey};
                 config.Branches.Add(branchKey, branchConfig);
                 return branchConfig;
             }
diff --git a/src/GitVersionCore/Configuration/IncrementStrategy.cs b/src/GitVersionCore/Configuration/IncrementStrategy.cs
@@ -9,7 +9,7 @@ public enum IncrementStrategy
         Minor,
         Patch,
         /// <summary>
-        /// Uses the <see cref="BranchConfig.Increment"/>, <see cref="BranchConfig.PreventIncrementOfMergedBranchVersion"/> and <see cref="BranchConfig.IsDevelop"/>
+        /// Uses the <see cref="BranchConfig.Increment"/>, <see cref="BranchConfig.PreventIncrementOfMergedBranchVersion"/> and <see cref="BranchConfig.TracksReleaseBranches"/>
         /// of the "parent" branch (i.e. the branch where the current branch was branched from).
         /// </summary>
         Inherit
diff --git a/src/GitVersionCore/Configuration/Init/SetConfig/ConfigureBranches.cs b/src/GitVersionCore/Configuration/Init/SetConfig/ConfigureBranches.cs
@@ -29,7 +29,7 @@ protected override StepResult HandleResult(string result, Queue<ConfigInitWizard
                     var branchConfig = foundBranch.Value;
                     if (branchConfig == null)
                     {
-                        branchConfig = new BranchConfig();
+                        branchConfig = new BranchConfig {Name = foundBranch.Key};
                         config.Branches.Add(foundBranch.Key, branchConfig);
                     }
                     steps.Enqueue(new ConfigureBranch(foundBranch.Key, branchConfig, Console, FileSystem));
diff --git a/src/GitVersionCore/GitVersionContext.cs b/src/GitVersionCore/GitVersionContext.cs
@@ -83,18 +83,18 @@ void CalculateEffectiveConfiguration()
         {
             var currentBranchConfig = BranchConfigurationCalculator.GetBranchConfiguration(CurrentCommit, Repository, OnlyEvaluateTrackedBranches, FullConfiguration, CurrentBranch);
 
-            if (!currentBranchConfig.Value.VersioningMode.HasValue)
-                throw new Exception(string.Format("Configuration value for 'Versioning mode' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
-            if (!currentBranchConfig.Value.Increment.HasValue)
-                throw new Exception(string.Format("Configuration value for 'Increment' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
-            if (!currentBranchConfig.Value.PreventIncrementOfMergedBranchVersion.HasValue)
-                throw new Exception(string.Format("Configuration value for 'PreventIncrementOfMergedBranchVersion' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
-            if (!currentBranchConfig.Value.TrackMergeTarget.HasValue)
-                throw new Exception(string.Format("Configuration value for 'TrackMergeTarget' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
-            if (!currentBranchConfig.Value.TracksReleaseBranches.HasValue)
-                throw new Exception(string.Format("Configuration value for 'TracksReleaseBranches' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
-            if (!currentBranchConfig.Value.IsReleaseBranch.HasValue)
-                throw new Exception(string.Format("Configuration value for 'IsReleaseBranch' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Key));
+            if (!currentBranchConfig.VersioningMode.HasValue)
+                throw new Exception(string.Format("Configuration value for 'Versioning mode' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
+            if (!currentBranchConfig.Increment.HasValue)
+                throw new Exception(string.Format("Configuration value for 'Increment' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
+            if (!currentBranchConfig.PreventIncrementOfMergedBranchVersion.HasValue)
+                throw new Exception(string.Format("Configuration value for 'PreventIncrementOfMergedBranchVersion' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
+            if (!currentBranchConfig.TrackMergeTarget.HasValue)
+                throw new Exception(string.Format("Configuration value for 'TrackMergeTarget' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
+            if (!currentBranchConfig.TracksReleaseBranches.HasValue)
+                throw new Exception(string.Format("Configuration value for 'TracksReleaseBranches' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
+            if (!currentBranchConfig.IsReleaseBranch.HasValue)
+                throw new Exception(string.Format("Configuration value for 'IsReleaseBranch' for branch {0} has no value. (this should not happen, please report an issue)", currentBranchConfig.Name));
 
             if (!FullConfiguration.AssemblyVersioningScheme.HasValue)
                 throw new Exception("Configuration value for 'AssemblyVersioningScheme' has no value. (this should not happen, please report an issue)");
@@ -107,12 +107,12 @@ void CalculateEffectiveConfiguration()
             if (!FullConfiguration.CommitsSinceVersionSourcePadding.HasValue)
                 throw new Exception("Configuration value for 'CommitsSinceVersionSourcePadding' has no value. (this should not happen, please report an issue)");
 
-            var versioningMode = currentBranchConfig.Value.VersioningMode.Value;
-            var tag = currentBranchConfig.Value.Tag;
-            var tagNumberPattern = currentBranchConfig.Value.TagNumberPattern;
-            var incrementStrategy = currentBranchConfig.Value.Increment.Value;
-            var preventIncrementForMergedBranchVersion = currentBranchConfig.Value.PreventIncrementOfMergedBranchVersion.Value;
-            var trackMergeTarget = currentBranchConfig.Value.TrackMergeTarget.Value;
+            var versioningMode = currentBranchConfig.VersioningMode.Value;
+            var tag = currentBranchConfig.Tag;
+            var tagNumberPattern = currentBranchConfig.TagNumberPattern;
+            var incrementStrategy = currentBranchConfig.Increment.Value;
+            var preventIncrementForMergedBranchVersion = currentBranchConfig.PreventIncrementOfMergedBranchVersion.Value;
+            var trackMergeTarget = currentBranchConfig.TrackMergeTarget.Value;
 
             var nextVersion = FullConfiguration.NextVersion;
             var assemblyVersioningScheme = FullConfiguration.AssemblyVersioningScheme.Value;
@@ -123,12 +123,12 @@ void CalculateEffectiveConfiguration()
             var patchMessage = FullConfiguration.PatchVersionBumpMessage;
             var noBumpMessage = FullConfiguration.NoBumpMessage;
 
-            var commitMessageVersionBump = currentBranchConfig.Value.CommitMessageIncrementing ?? FullConfiguration.CommitMessageIncrementing.Value;
+            var commitMessageVersionBump = currentBranchConfig.CommitMessageIncrementing ?? FullConfiguration.CommitMessageIncrementing.Value;
 
             Configuration = new EffectiveConfiguration(
                 assemblyVersioningScheme, assemblyInformationalFormat, versioningMode, gitTagPrefix,
                 tag, nextVersion, incrementStrategy,
-                currentBranchConfig.Value.Regex,
+                currentBranchConfig.Regex,
                 preventIncrementForMergedBranchVersion,
                 tagNumberPattern, FullConfiguration.ContinuousDeploymentFallbackTag,
                 trackMergeTarget,
@@ -138,8 +138,8 @@ void CalculateEffectiveConfiguration()
                 FullConfiguration.BuildMetaDataPadding.Value,
                 FullConfiguration.CommitsSinceVersionSourcePadding.Value,
                 FullConfiguration.Ignore.ToFilters(),
-                currentBranchConfig.Value.TracksReleaseBranches.Value,
-                currentBranchConfig.Value.IsReleaseBranch.Value);
+                currentBranchConfig.TracksReleaseBranches.Value,
+                currentBranchConfig.IsReleaseBranch.Value);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,6 @@`
`4`	`4`	`using GitVersionCore.Tests;`
`5`	`5`	`using LibGit2Sharp;`
`6`	`6`	`using NUnit.Framework;`
`7`		`-using System.Collections.Generic;`
`8`	`7`
`9`	`8`	`[TestFixture]`
`10`	`9`	`public class FeatureBranchScenarios`
`@@ -296,7 +295,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchCreated()`
`296`	`295`	`{`
`297`	`296`	`"master", new BranchConfig()`
`298`	`297`	`{`
`299`		`- IsDevelop = true,`
	`298`	`+ TracksReleaseBranches = true,`
`300`	`299`	`Regex = "master"`
`301`	`300`	`}`
`302`	`301`	`}`
`@@ -329,7 +328,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchMergedBack()`
`329`	`328`	`{`
`330`	`329`	`"master", new BranchConfig()`
`331`	`330`	`{`
`332`		`- IsDevelop = true,`
	`331`	`+ TracksReleaseBranches = true,`
`333`	`332`	`Regex = "master"`
`334`	`333`	`}`
`335`	`334`	`}`
`@@ -414,7 +413,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchCreated()`
`414`	`413`	`{`
`415`	`414`	`"master", new BranchConfig()`
`416`	`415`	`{`
`417`		`- IsDevelop = true,`
	`416`	`+ TracksReleaseBranches = true,`
`418`	`417`	`Regex = "master"`
`419`	`418`	`}`
`420`	`419`	`}`
`@@ -447,7 +446,7 @@ public void ShouldPickUpVersionFromMasterAfterReleaseBranchMergedBack()`
`447`	`446`	`{`
`448`	`447`	`"master", new BranchConfig()`
`449`	`448`	`{`
`450`		`- IsDevelop = true,`
	`449`	`+ TracksReleaseBranches = true,`
`451`	`450`	`Regex = "master"`
`452`	`451`	`}`
`453`	`452`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,38 +9,41 @@ namespace GitVersion`
`9`	`9`
`10`	`10`	`public class BranchConfigurationCalculator`
`11`	`11`	`{`
`12`		`- public static KeyValuePair<string, BranchConfig> GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)`
	`12`	`+ /// <summary>`
	`13`	`+ /// Gets the <see cref="BranchConfig"/> for the current commit.`
	`14`	`+ /// </summary>`
	`15`	`+ public static BranchConfig GetBranchConfiguration(Commit currentCommit, IRepository repository, bool onlyEvaluateTrackedBranches, Config config, Branch currentBranch, IList<Branch> excludedInheritBranches = null)`
`13`	`16`	`{`
`14`		`- var matchingBranches = LookupBranchConfiguration(config, currentBranch);`
	`17`	`+ var matchingBranches = LookupBranchConfiguration(config, currentBranch).ToArray();`
`15`	`18`
`16`	`19`	`if (matchingBranches.Length == 0)`
`17`	`20`	`{`
`18`	`21`	`Logger.WriteInfo(string.Format(`
`19`	`22`	`"No branch configuration found for branch {0}, falling back to default configuration",`
`20`	`23`	`currentBranch.FriendlyName));`
`21`	`24`
`22`		`- var branchConfig = new BranchConfig();`
	`25`	`+ var branchConfig = new BranchConfig { Name = string.Empty };`
`23`	`26`	`ConfigurationProvider.ApplyBranchDefaults(config, branchConfig, "");`
`24`		`- return new KeyValuePair<string, BranchConfig>(string.Empty, branchConfig);`
	`27`	`+ return branchConfig;`
`25`	`28`	`}`
	`29`	`+`
`26`	`30`	`if (matchingBranches.Length == 1)`
`27`	`31`	`{`
`28`		`- var keyValuePair = matchingBranches[0];`
`29`		`- var branchConfiguration = keyValuePair.Value;`
	`32`	`+ var branchConfiguration = matchingBranches[0];`
`30`	`33`
`31`	`34`	`if (branchConfiguration.Increment == IncrementStrategy.Inherit)`
`32`	`35`	`{`
`33`		`- return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, keyValuePair, branchConfiguration, config, excludedInheritBranches);`
	`36`	`+ return InheritBranchConfiguration(onlyEvaluateTrackedBranches, repository, currentCommit, currentBranch, branchConfiguration, config, excludedInheritBranches);`
`34`	`37`	`}`
`35`	`38`
`36`		`- return keyValuePair;`
	`39`	`+ return branchConfiguration;`
`37`	`40`	`}`
`38`	`41`
`39`	`42`	`const string format = "Multiple branch configurations match the current branch branchName of '{0}'. Matching configurations: '{1}'";`
`40`		`- throw new Exception(string.Format(format, currentBranch.FriendlyName, string.Join(", ", matchingBranches.Select(b => b.Key))));`
	`43`	`+ throw new Exception(string.Format(format, currentBranch.FriendlyName, string.Join(", ", matchingBranches.Select(b => b.Name))));`
`41`	`44`	`}`
`42`	`45`
`43`		`- static KeyValuePair<string, BranchConfig>[] LookupBranchConfiguration([NotNull] Config config, [NotNull] Branch currentBranch)`
	`46`	`+ static IEnumerable<BranchConfig> LookupBranchConfiguration([NotNull] Config config, [NotNull] Branch currentBranch)`
`44`	`47`	`{`
`45`	`48`	`if (config == null)`
`46`	`49`	`{`
`@@ -52,11 +55,11 @@ static KeyValuePair<string, BranchConfig>[] LookupBranchConfiguration([NotNull]`
`52`	`55`	`throw new ArgumentNullException("currentBranch");`
`53`	`56`	`}`
`54`	`57`
`55`		`- return config.Branches.Where(b => Regex.IsMatch(currentBranch.FriendlyName, "^" + b.Value.Regex, RegexOptions.IgnoreCase)).ToArray();`
	`58`	`+ return config.Branches.Where(b => Regex.IsMatch(currentBranch.FriendlyName, "^" + b.Value.Regex, RegexOptions.IgnoreCase)).Select(kvp => kvp.Value);`
`56`	`59`	`}`
`57`	`60`
`58`	`61`
`59`		`- static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEvaluateTrackedBranches, IRepository repository, Commit currentCommit, Branch currentBranch, KeyValuePair<string, BranchConfig> keyValuePair, BranchConfig branchConfiguration, Config config, IList<Branch> excludedInheritBranches)`
	`62`	`+ static BranchConfig InheritBranchConfiguration(bool onlyEvaluateTrackedBranches, IRepository repository, Commit currentCommit, Branch currentBranch, BranchConfig branchConfiguration, Config config, IList<Branch> excludedInheritBranches)`
`60`	`63`	`{`
`61`	`64`	`using (Logger.IndentLog("Attempting to inherit branch configuration from parent branch"))`
`62`	`65`	`{`
`@@ -72,11 +75,11 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv`
`72`	`75`	`{`
`73`	`76`	`excludedInheritBranches = repository.Branches.Where(b =>`
`74`	`77`	`{`
`75`		`- var branchConfig = LookupBranchConfiguration(config, b);`
	`78`	`+ var branchConfig = LookupBranchConfiguration(config, b).ToArray();`
`76`	`79`
`77`	`80`	`// NOTE: if length is 0 we couldn't find the configuration for the branch e.g. "origin/master"`
`78`	`81`	`// NOTE: if the length is greater than 1 we cannot decide which merge strategy to pick`
`79`		`- return (branchConfig.Length != 1) \|\| (branchConfig.Length == 1 && branchConfig[0].Value.Increment == IncrementStrategy.Inherit);`
	`82`	`+ return (branchConfig.Length != 1) \|\| (branchConfig.Length == 1 && branchConfig[0].Increment == IncrementStrategy.Inherit);`
`80`	`83`	`}).ToList();`
`81`	`84`	`}`
`82`	`85`	`excludedBranches.ToList().ForEach(excludedInheritBranches.Add);`
`@@ -110,16 +113,14 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv`
`110`	`113`
`111`	`114`	`if (possibleParents.Count == 1)`
`112`	`115`	`{`
`113`		`- var branchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, possibleParents[0], excludedInheritBranches).Value;`
`114`		`- return new KeyValuePair<string, BranchConfig>(`
`115`		`- keyValuePair.Key,`
`116`		`- new BranchConfig(branchConfiguration)`
`117`		`- {`
`118`		`- Increment = branchConfig.Increment,`
`119`		`- PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,`
`120`		`- // If we are inheriting from develop then we should behave like develop`
`121`		`- TracksReleaseBranches = branchConfig.TracksReleaseBranches`
`122`		`- });`
	`116`	`+ var branchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, possibleParents[0], excludedInheritBranches);`
	`117`	`+ return new BranchConfig(branchConfiguration)`
	`118`	`+ {`
	`119`	`+ Increment = branchConfig.Increment,`
	`120`	`+ PreventIncrementOfMergedBranchVersion = branchConfig.PreventIncrementOfMergedBranchVersion,`
	`121`	`+ // If we are inheriting from develop then we should behave like develop`
	`122`	`+ TracksReleaseBranches = branchConfig.TracksReleaseBranches`
	`123`	`+ };`
`123`	`124`	`}`
`124`	`125`
`125`	`126`	`// 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`
`@@ -142,16 +143,14 @@ static KeyValuePair<string, BranchConfig> InheritBranchConfiguration(bool onlyEv`
`142`	`143`	`var branchName = chosenBranch.FriendlyName;`
`143`	`144`	`Logger.WriteWarning(errorMessage + Environment.NewLine + Environment.NewLine + "Falling back to " + branchName + " branch config");`
`144`	`145`
`145`		`- var inheritingBranchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, chosenBranch).Value;`
`146`		`- return new KeyValuePair<string, BranchConfig>(`
`147`		`- keyValuePair.Key,`
`148`		`- new BranchConfig(branchConfiguration)`
`149`		`- {`
`150`		`- Increment = inheritingBranchConfig.Increment,`
`151`		`- PreventIncrementOfMergedBranchVersion = inheritingBranchConfig.PreventIncrementOfMergedBranchVersion,`
`152`		`- // If we are inheriting from develop then we should behave like develop`
`153`		`- TracksReleaseBranches = inheritingBranchConfig.TracksReleaseBranches`
`154`		`- });`
	`146`	`+ var inheritingBranchConfig = GetBranchConfiguration(currentCommit, repository, onlyEvaluateTrackedBranches, config, chosenBranch);`
	`147`	`+ return new BranchConfig(branchConfiguration)`
	`148`	`+ {`
	`149`	`+ Increment = inheritingBranchConfig.Increment,`
	`150`	`+ PreventIncrementOfMergedBranchVersion = inheritingBranchConfig.PreventIncrementOfMergedBranchVersion,`
	`151`	`+ // If we are inheriting from develop then we should behave like develop`
	`152`	`+ TracksReleaseBranches = inheritingBranchConfig.TracksReleaseBranches`
	`153`	`+ };`
`155`	`154`	`}`
`156`	`155`	`}`
`157`	`156`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,7 @@ public BranchConfig(BranchConfig branchConfiguration)`
`24`	`24`	`Regex = branchConfiguration.Regex;`
`25`	`25`	`IsReleaseBranch = branchConfiguration.IsReleaseBranch;`
`26`	`26`	`IsMainline = branchConfiguration.IsMainline;`
	`27`	`+ Name = branchConfiguration.Name;`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`[YamlMember(Alias = "mode")]`
`@@ -61,5 +62,11 @@ public BranchConfig(BranchConfig branchConfiguration)`
`61`	`62`
`62`	`63`	`[YamlMember(Alias = "is-mainline")]`
`63`	`64`	`public bool? IsMainline { get; set; }`
	`65`	`+`
	`66`	`+ /// <summary>`
	`67`	`+ /// The name given to this configuration in the config file.`
	`68`	`+ /// </summary>`
	`69`	`+ [YamlIgnore]`
	`70`	`+ public string Name { get; set; }`
`64`	`71`	`}`
`65`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ public Dictionary<string, BranchConfig> Branches`
`79`	`79`	`value.ToList().ForEach(_ =>`
`80`	`80`	`{`
`81`	`81`	`if (!branches.ContainsKey(_.Key))`
`82`		`- branches.Add(_.Key, new BranchConfig());`
	`82`	`+ branches.Add(_.Key, new BranchConfig {Name = _.Key});`
`83`	`83`
`84`	`84`	`branches[_.Key] = MergeObjects(branches[_.Key], _.Value);`
`85`	`85`	`});`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ static BranchConfig GetOrCreateBranchDefaults(Config config, string branchKey)`
`147`	`147`	`{`
`148`	`148`	`if (!config.Branches.ContainsKey(branchKey))`
`149`	`149`	`{`
`150`		`- var branchConfig = new BranchConfig();`
	`150`	`+ var branchConfig = new BranchConfig {Name = branchKey};`
`151`	`151`	`config.Branches.Add(branchKey, branchConfig);`
`152`	`152`	`return branchConfig;`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ protected override StepResult HandleResult(string result, Queue<ConfigInitWizard`
`29`	`29`	`var branchConfig = foundBranch.Value;`
`30`	`30`	`if (branchConfig == null)`
`31`	`31`	`{`
`32`		`- branchConfig = new BranchConfig();`
	`32`	`+ branchConfig = new BranchConfig {Name = foundBranch.Key};`
`33`	`33`	`config.Branches.Add(foundBranch.Key, branchConfig);`
`34`	`34`	`}`
`35`	`35`	`steps.Enqueue(new ConfigureBranch(foundBranch.Key, branchConfig, Console, FileSystem));`