Few minor changes, moving increment logic to SemVer class

GitVersionCore.Tests/Fixtures/RepositoryFixtureBase.cs

@@ -24,6 +24,7 @@ protected RepositoryFixtureBase(Func<string, IRepository> repoBuilder, Config co
 
     public void AssertFullSemver(string fullSemver, IRepository repository = null, string commitId = null)
     {
+        Trace.WriteLine("---------");
         var gitVersionContext = new GitVersionContext(repository ?? Repository, configuration, IsForTrackedBranchOnly, commitId);
         var executeGitVersion = ExecuteGitVersion(gitVersionContext);
         var variables = VariableProvider.GetVariablesFor(executeGitVersion, 
@@ -38,7 +39,7 @@ public void AssertFullSemver(string fullSemver, IRepository repository = null, s
         catch (Exception)
         {
             Trace.WriteLine("Test failing, dumping repository graph");
-            repository.DumpGraph();
+            gitVersionContext.Repository.DumpGraph();
             throw;
         }
     }

GitVersionCore/EffectiveConfiguration.cs

@@ -53,6 +53,7 @@ public EffectiveConfiguration(
         public string TagNumberPattern { get; private set; }
 
         public string ContinuousDeploymentFallbackTag { get; private set; }
+
         public bool TrackMergeTarget { get; private set; }
     }
 }

GitVersionCore/GitVersionFinder.cs

@@ -10,7 +10,7 @@ public class GitVersionFinder
     {
         public SemanticVersion FindVersion(GitVersionContext context)
         {
-            Logger.WriteInfo("Running against branch: " + context.CurrentBranch.Name);
+            Logger.WriteInfo(string.Format("Running against branch: {0} ({1})", context.CurrentBranch.Name, context.CurrentCommit.Sha));
             EnsureMainTopologyConstraints(context);
 
             var filePath = Path.Combine(context.Repository.GetRepositoryDirectory(), "NextVersion.txt");

GitVersionCore/SemanticVersion.cs

@@ -271,5 +271,47 @@ public string ToString(string format, IFormatProvider formatProvider = null)
                     throw new ArgumentException(string.Format("Unrecognised format '{0}'", format), "format");
             }
         }
+
+        public SemanticVersion IncrementVersion(IncrementStrategy incrementStrategy)
+        {
+            var incremented = new SemanticVersion(this);
+            if (!incremented.PreReleaseTag.HasTag())
+            {
+                switch (incrementStrategy)
+                {
+                    case IncrementStrategy.None:
+                        Logger.WriteInfo("Skipping version increment");
+                        break;
+                    case IncrementStrategy.Major:
+                        Logger.WriteInfo("Incrementing Major Version");
+                        incremented.Major++;
+                        incremented.Minor = 0;
+                        incremented.Patch = 0;
+                        break;
+                    case IncrementStrategy.Minor:
+                        incremented.Minor++;
+                        incremented.Patch = 0;
+                        Logger.WriteInfo("Incrementing Minor Version");
+                        break;
+                    case IncrementStrategy.Patch:
+                        incremented.Patch++;
+                        Logger.WriteInfo("Incrementing Patch Version");
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+            else
+            {
+                if (incremented.PreReleaseTag.Number != null)
+                {
+                    Logger.WriteInfo("Incrementing prerelease");
+                    incremented.PreReleaseTag.Number = incremented.PreReleaseTag.Number;
+                    incremented.PreReleaseTag.Number++;
+                }
+            }
+
+            return incremented;
+        }
     }
 }

GitVersionCore/VersionCalculation/BaseVersionCalculators/BaseVersion.cs

@@ -25,7 +25,7 @@ public BaseVersion(string source, bool shouldIncrement, SemanticVersion semantic
 
         public override string ToString()
         {
-            return string.Format("{0}: {1} from commit {2}", Source, SemanticVersion.ToString("f"), BaseVersionSource == null ? "External Source" : BaseVersionSource.Sha);
+            return string.Format("{0}: {1} with commit count source {2}", Source, SemanticVersion.ToString("f"), BaseVersionSource == null ? "External Source" : BaseVersionSource.Sha);
         }
     }
 }

GitVersionCore/VersionCalculation/FallbackBaseVersionStrategy.cs

@@ -1,13 +1,18 @@
 namespace GitVersion.VersionCalculation
 {
     using System.Linq;
-    using GitVersion.VersionCalculation.BaseVersionCalculators;
+    using BaseVersionCalculators;
+    using LibGit2Sharp;
 
     public class FallbackBaseVersionStrategy : BaseVersionStrategy
     {
         public override BaseVersion GetVersion(GitVersionContext context)
         {
-            return new BaseVersion("Fallback base version", false, new SemanticVersion(minor: 1), context.CurrentBranch.Commits.Last(), null);
+            var baseVersionSource = context.Repository.Commits.QueryBy(new CommitFilter
+            {
+                Since = context.CurrentBranch.Tip
+            }).First(c => !c.Parents.Any());
+            return new BaseVersion("Fallback base version", false, new SemanticVersion(minor: 1), baseVersionSource, null);
         }
     }
 }

GitVersionCore/VersionCalculation/NextVersionCalculator.cs

@@ -1,8 +1,7 @@
 namespace GitVersion.VersionCalculation
 {
-    using System;
     using System.Text.RegularExpressions;
-    using BaseVersionCalculators;
+    using GitVersion.VersionCalculation.BaseVersionCalculators;
 
     public class NextVersionCalculator
     {
@@ -40,27 +39,30 @@ public SemanticVersion FindVersion(GitVersionContext context)
             }
 
             var baseVersion = baseVersionFinder.GetBaseVersion(context);
-
-            if (baseVersion.ShouldIncrement) IncrementVersion(context, baseVersion);
+            var semver = baseVersion.SemanticVersion;
+            if (baseVersion.ShouldIncrement)
+            {
+                semver = semver.IncrementVersion(context.Configuration.Increment);
+            }
             else Logger.WriteInfo("Skipping version increment");
 
-            if (!baseVersion.SemanticVersion.PreReleaseTag.HasTag() && !string.IsNullOrEmpty(context.Configuration.Tag))
+            if (!semver.PreReleaseTag.HasTag() && !string.IsNullOrEmpty(context.Configuration.Tag))
             {
-                UpdatePreReleaseTag(context, baseVersion);
+                UpdatePreReleaseTag(context, semver, baseVersion.BranchNameOverride);
             }
 
-            baseVersion.SemanticVersion.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionSource, context);
+            semver.BuildMetaData = metaDataCalculator.Create(baseVersion.BaseVersionSource, context);
 
-            return baseVersion.SemanticVersion;
+            return semver;
         }
 
-        void UpdatePreReleaseTag(GitVersionContext context, BaseVersion baseVersion)
+        void UpdatePreReleaseTag(GitVersionContext context, SemanticVersion semanticVersion, string branchNameOverride)
         {
             var tagToUse = context.Configuration.Tag;
             if (tagToUse == "useBranchName")
             {
                 Logger.WriteInfo("Using branch name to calculate version tag");
-                var name = baseVersion.BranchNameOverride ?? context.CurrentBranch.Name;
+                var name = branchNameOverride ?? context.CurrentBranch.Name;
                 tagToUse = name.RegexReplace(context.Configuration.BranchPrefixToTrim, string.Empty, RegexOptions.IgnoreCase);
             }
             int? number = null;
@@ -77,7 +79,7 @@ void UpdatePreReleaseTag(GitVersionContext context, BaseVersion baseVersion)
             var lastTag = highestTagBaseVersionStrategy.GetVersion(context);
             if (number == null &&
                 lastTag != null &&
-                MajorMinorPatchEqual(lastTag.SemanticVersion, baseVersion.SemanticVersion) &&
+                MajorMinorPatchEqual(lastTag.SemanticVersion, semanticVersion) &&
                 lastTag.SemanticVersion.PreReleaseTag.HasTag())
             {
                 number = lastTag.SemanticVersion.PreReleaseTag.Number + 1;
@@ -88,7 +90,7 @@ void UpdatePreReleaseTag(GitVersionContext context, BaseVersion baseVersion)
                 number = 1;
             }
 
-            baseVersion.SemanticVersion.PreReleaseTag = new SemanticVersionPreReleaseTag(tagToUse, number);
+            semanticVersion.PreReleaseTag = new SemanticVersionPreReleaseTag(tagToUse, number);
         }
 
         static bool MajorMinorPatchEqual(SemanticVersion lastTag, SemanticVersion baseVersion)
@@ -97,43 +99,5 @@ static bool MajorMinorPatchEqual(SemanticVersion lastTag, SemanticVersion baseVe
                    lastTag.Minor == baseVersion.Minor &&
                    lastTag.Patch == baseVersion.Patch;
         }
-
-        static void IncrementVersion(GitVersionContext context, BaseVersion baseVersion)
-        {
-            if (!baseVersion.SemanticVersion.PreReleaseTag.HasTag())
-            {
-                switch (context.Configuration.Increment)
-                {
-                    case IncrementStrategy.None:
-                        Logger.WriteInfo("Skipping version increment");
-                        break;
-                    case IncrementStrategy.Major:
-                        Logger.WriteInfo("Incrementing Major Version");
-                        baseVersion.SemanticVersion.Major++;
-                        baseVersion.SemanticVersion.Minor = 0;
-                        baseVersion.SemanticVersion.Patch = 0;
-                        break;
-                    case IncrementStrategy.Minor:
-                        baseVersion.SemanticVersion.Minor++;
-                        baseVersion.SemanticVersion.Patch = 0;
-                        Logger.WriteInfo("Incrementing Minor Version");
-                        break;
-                    case IncrementStrategy.Patch:
-                        baseVersion.SemanticVersion.Patch++;
-                        Logger.WriteInfo("Incrementing Patch Version");
-                        break;
-                    default:
-                        throw new ArgumentOutOfRangeException();
-                }
-            }
-            else
-            {
-                if (baseVersion.SemanticVersion.PreReleaseTag.Number != null)
-                {
-                    baseVersion.SemanticVersion.PreReleaseTag.Number = baseVersion.SemanticVersion.PreReleaseTag.Number;
-                    baseVersion.SemanticVersion.PreReleaseTag.Number++;
-                }
-            }
-        }
     }
 }