Deleted IFileSystem.TreeWalkForDotGitDir() and replaced its usage with Repository.Discover().

asbjornu · JakeGinnivan · commit ec2d79647b02 · 2016-01-17T09:02:05.000+08:00
diff --git a/src/GitVersionCore.Tests/FileSystemTests.cs b/src/GitVersionCore.Tests/FileSystemTests.cs
@@ -11,16 +11,13 @@ public class FileSystemTests
 {
     string workDirectory;
     string gitDirectory;
-    IFileSystem fileSystem;
 
     [SetUp]
     public void CreateTemporaryRepository()
     {
-        this.fileSystem = new FileSystem();
         workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
 
-        gitDirectory = Repository.Init(workDirectory)
-                        .TrimEnd(new[] { Path.DirectorySeparatorChar });
+        gitDirectory = Repository.Init(workDirectory);
 
         Assert.NotNull(gitDirectory);
     }
@@ -34,26 +31,26 @@ public void Cleanup()
     [Test]
     public void From_WorkingDirectory()
     {
-        Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(workDirectory));
+        Assert.AreEqual(gitDirectory, Repository.Discover(workDirectory));
     }
 
     [Test]
     public void From_WorkingDirectory_Parent()
     {
         var parentDirectory = Directory.GetParent(workDirectory).FullName;
-        Assert.Null(fileSystem.TreeWalkForDotGitDir(parentDirectory));
+        Assert.Null(Repository.Discover(parentDirectory));
     }
 
     [Test]
     public void From_GitDirectory()
     {
-        Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(gitDirectory));
+        Assert.AreEqual(gitDirectory, Repository.Discover(gitDirectory));
     }
 
     [Test]
     public void From_RefsDirectory()
     {
         var refsDirectory = Path.Combine(gitDirectory, "refs");
-        Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(refsDirectory));
+        Assert.AreEqual(gitDirectory, Repository.Discover(refsDirectory));
     }
 }
diff --git a/src/GitVersionCore.Tests/Fixtures/RemoteRepositoryFixture.cs b/src/GitVersionCore.Tests/Fixtures/RemoteRepositoryFixture.cs
@@ -26,7 +26,7 @@ public RemoteRepositoryFixture(Config configuration)
     /// </summary>
     public void InitialiseRepo()
     {
-        new GitPreparer(null, null, new Authentication(), false, LocalRepositoryFixture.RepositoryPath, new FileSystem()).Initialise(true, null);
+        new GitPreparer(null, null, new Authentication(), false, LocalRepositoryFixture.RepositoryPath).Initialise(true, null);
     }
 
     static IRepository CreateNewRepository(string path)
diff --git a/src/GitVersionCore.Tests/GitPreparerTests.cs b/src/GitVersionCore.Tests/GitPreparerTests.cs
@@ -39,7 +39,7 @@ public void WorksCorrectlyWithRemoteRepository(string branchName, string expecte
                 // Copy contents into working directory
                 File.Copy(Path.Combine(fixture.RepositoryPath, "TestFile.txt"), Path.Combine(tempDir, "TestFile.txt"));
 
-                var gitPreparer = new GitPreparer(fixture.RepositoryPath, null, new Authentication(), false, tempDir, new FileSystem());
+                var gitPreparer = new GitPreparer(fixture.RepositoryPath, null, new Authentication(), false, tempDir);
                 gitPreparer.Initialise(false, branchName);
                 dynamicRepositoryPath = gitPreparer.GetDotGitDirectory();
 
@@ -77,7 +77,7 @@ public void UpdatesExistingDynamicRepository()
             {
                 mainRepositoryFixture.Repository.MakeCommits(1);
 
-                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir, new FileSystem());
+                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir);
                 gitPreparer.Initialise(false, "master");
                 dynamicRepositoryPath = gitPreparer.GetDotGitDirectory();
 
@@ -118,7 +118,7 @@ public void PicksAnotherDirectoryNameWhenDynamicRepoFolderTaken()
                 expectedDynamicRepoLocation = Path.Combine(tempPath, fixture.RepositoryPath.Split('\\').Last());
                 Directory.CreateDirectory(expectedDynamicRepoLocation);
 
-                var gitPreparer = new GitPreparer(fixture.RepositoryPath, null, new Authentication(), false, tempDir, new FileSystem());
+                var gitPreparer = new GitPreparer(fixture.RepositoryPath, null, new Authentication(), false, tempDir);
                 gitPreparer.Initialise(false, "master");
 
                 gitPreparer.IsDynamicGitRepository.ShouldBe(true);
@@ -139,7 +139,7 @@ public void PicksAnotherDirectoryNameWhenDynamicRepoFolderTaken()
     public void WorksCorrectlyWithLocalRepository()
     {
         var tempDir = Path.GetTempPath();
-        var gitPreparer = new GitPreparer(null, null, null, false, tempDir, new FileSystem());
+        var gitPreparer = new GitPreparer(null, null, null, false, tempDir);
         var dynamicRepositoryPath = gitPreparer.GetDotGitDirectory();
 
         dynamicRepositoryPath.ShouldBe(null);
@@ -160,7 +160,7 @@ public void UsingDynamicRepositoryWithFeatureBranchWorks()
             {
                 mainRepositoryFixture.Repository.MakeACommit();
 
-                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir, new FileSystem());
+                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir);
                 gitPreparer.Initialise(true, "feature1");
 
                 mainRepositoryFixture.Repository.Checkout(mainRepositoryFixture.Repository.CreateBranch("feature1"));
@@ -188,7 +188,7 @@ public void UsingDynamicRepositoryWithoutTargetBranchFails()
             {
                 mainRepositoryFixture.Repository.MakeACommit();
 
-                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir, new FileSystem());
+                var gitPreparer = new GitPreparer(mainRepositoryFixture.RepositoryPath, null, new Authentication(), false, tempDir);
 
                 Should.Throw<Exception>(() => gitPreparer.Initialise(true, null));
             }
@@ -209,7 +209,7 @@ public void TestErrorThrownForInvalidRepository()
 
         try
         {
-            var gitPreparer = new GitPreparer("http://127.0.0.1/testrepo.git", null, new Authentication(), false, tempDir, new FileSystem());
+            var gitPreparer = new GitPreparer("http://127.0.0.1/testrepo.git", null, new Authentication(), false, tempDir);
 
             Should.Throw<Exception>(() => gitPreparer.Initialise(true, "master"));
         }
diff --git a/src/GitVersionCore.Tests/TestFileSystem.cs b/src/GitVersionCore.Tests/TestFileSystem.cs
@@ -93,12 +93,6 @@ public long GetLastDirectoryWrite(string path)
     }
 
 
-    public string TreeWalkForDotGitDir(string directory)
-    {
-        return directory;
-    }
-
-
     public IRepository GetRepository(string gitDirectory)
     {
         var repository = Substitute.For<IRepository>();
diff --git a/src/GitVersionCore/ExecuteCore.cs b/src/GitVersionCore/ExecuteCore.cs
@@ -2,14 +2,15 @@ namespace GitVersion
 {
     using System;
     using System.Linq;
+
     using GitVersion.Helpers;
 
     public static class ExecuteCore
     {
         public static VersionVariables ExecuteGitVersion(IFileSystem fileSystem, string targetUrl, string dynamicRepositoryLocation, Authentication authentication, string targetBranch, bool noFetch, string workingDirectory, string commitId)
         {
             // Normalise if we are running on build server
-            var gitPreparer = new GitPreparer(targetUrl, dynamicRepositoryLocation, authentication, noFetch, workingDirectory, fileSystem);
+            var gitPreparer = new GitPreparer(targetUrl, dynamicRepositoryLocation, authentication, noFetch, workingDirectory);
             var applicableBuildServers = BuildServerList.GetApplicableBuildServers();
             var buildServer = applicableBuildServers.FirstOrDefault();
 
@@ -29,17 +30,21 @@ public static VersionVariables ExecuteGitVersion(IFileSystem fileSystem, string
 
             using (var repo = fileSystem.GetRepository(dotGitDirectory))
             {
-                var gitVersionContext = new GitVersionContext(repo, configuration, commitId: commitId);
+                var gitVersionContext = new GitVersionContext(repo, configuration, commitId : commitId);
                 var semanticVersion = versionFinder.FindVersion(gitVersionContext);
                 variables = VariableProvider.GetVariablesFor(semanticVersion, gitVersionContext.Configuration, gitVersionContext.IsCurrentCommitTagged);
             }
 
             return variables;
         }
 
-        private static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch)
+
+        static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch)
         {
-            if (buildServer == null) return targetBranch;
+            if (buildServer == null)
+            {
+                return targetBranch;
+            }
 
             var currentBranch = buildServer.GetCurrentBranch() ?? targetBranch;
             Logger.WriteInfo("Branch from build environment: " + currentBranch);
diff --git a/src/GitVersionCore/GitPreparer.cs b/src/GitVersionCore/GitPreparer.cs
@@ -4,42 +4,35 @@ namespace GitVersion
     using System.IO;
     using System.Linq;
 
-    using GitVersion.Helpers;
-
     using LibGit2Sharp;
 
     public class GitPreparer
     {
-        string targetUrl;
-        string dynamicRepositoryLocation;
         Authentication authentication;
+        string dynamicRepositoryLocation;
         bool noFetch;
         string targetPath;
-        readonly IFileSystem fileSystem;
+        string targetUrl;
 
 
-        public GitPreparer(string targetUrl, string dynamicRepositoryLocation, Authentication authentication, bool noFetch, string targetPath, IFileSystem fileSystem)
+        public GitPreparer(string targetUrl, string dynamicRepositoryLocation, Authentication authentication, bool noFetch, string targetPath)
         {
-            if (fileSystem == null)
-            {
-                throw new ArgumentNullException("fileSystem");
-            }
-
             this.targetUrl = targetUrl;
             this.dynamicRepositoryLocation = dynamicRepositoryLocation;
             this.authentication = authentication;
             this.noFetch = noFetch;
             this.targetPath = targetPath;
-            this.fileSystem = fileSystem;
         }
 
+
         public bool IsDynamicGitRepository
         {
             get { return !string.IsNullOrWhiteSpace(DynamicGitRepositoryPath); }
         }
 
         public string DynamicGitRepositoryPath { get; private set; }
 
+
         public void Initialise(bool normaliseGitDirectory, string currentBranch)
         {
             if (string.IsNullOrWhiteSpace(targetUrl))
@@ -56,6 +49,7 @@ public void Initialise(bool normaliseGitDirectory, string currentBranch)
             DynamicGitRepositoryPath = CreateDynamicRepository(tempRepositoryPath, authentication, targetUrl, currentBranch, noFetch);
         }
 
+
         static string CalculateTemporaryRepositoryPath(string targetUrl, string dynamicRepositoryLocation)
         {
             var userTemp = dynamicRepositoryLocation ?? Path.GetTempPath();
@@ -81,6 +75,7 @@ static string CalculateTemporaryRepositoryPath(string targetUrl, string dynamicR
             return possiblePath;
         }
 
+
         static bool GitRepoHasMatchingRemote(string possiblePath, string targetUrl)
         {
             try
@@ -94,30 +89,34 @@ static bool GitRepoHasMatchingRemote(string possiblePath, string targetUrl)
             {
                 return false;
             }
-            
         }
 
+
         public string GetDotGitDirectory()
         {
             if (IsDynamicGitRepository)
+            {
                 return DynamicGitRepositoryPath;
+            }
 
-            return this.fileSystem.TreeWalkForDotGitDir(targetPath);
+            return Repository.Discover(this.targetPath);
         }
 
+
         public string GetProjectRootDirectory()
         {
             if (IsDynamicGitRepository)
                 return this.targetPath;
 
-            var gitDir = fileSystem.TreeWalkForDotGitDir(this.targetPath);
+            var gitDir = Repository.Discover(this.targetPath);
 
             if (String.IsNullOrEmpty(gitDir))
                 throw new DirectoryNotFoundException("Can't find the .git directory in " + targetPath);
 
             return Directory.GetParent(gitDir).FullName;
         }
 
+
         static string CreateDynamicRepository(string targetPath, Authentication authentication, string repositoryUrl, string targetBranch, bool noFetch)
         {
             if (string.IsNullOrWhiteSpace(targetBranch))
@@ -143,7 +142,8 @@ static string CreateDynamicRepository(string targetPath, Authentication authenti
             return gitDirectory;
         }
 
-        private static void CloneRepository(string repositoryUrl, string gitDirectory, Authentication authentication)
+
+        static void CloneRepository(string repositoryUrl, string gitDirectory, Authentication authentication)
         {
             Credentials credentials = null;
             if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password))
@@ -162,11 +162,11 @@ private static void CloneRepository(string repositoryUrl, string gitDirectory, A
             try
             {
                 Repository.Clone(repositoryUrl, gitDirectory,
-                    new CloneOptions
-                    {
-                        Checkout = false,
-                        CredentialsProvider = (url, usernameFromUrl, types) => credentials
-                    });
+                                 new CloneOptions
+                                 {
+                                     Checkout = false,
+                                     CredentialsProvider = (url, usernameFromUrl, types) => credentials
+                                 });
             }
             catch (LibGit2SharpException ex)
             {
@@ -183,7 +183,7 @@ private static void CloneRepository(string repositoryUrl, string gitDirectory, A
                 {
                     throw new Exception("Not found: The repository was not found");
                 }
-                
+
                 throw new Exception("There was an unknown problem with the Git repository you provided");
             }
         }
diff --git a/src/GitVersionCore/Helpers/FileSystem.cs b/src/GitVersionCore/Helpers/FileSystem.cs
@@ -80,19 +80,6 @@ public long GetLastDirectoryWrite(string path)
         }
 
 
-        public string TreeWalkForDotGitDir(string directory)
-        {
-            var gitDirectory = Repository.Discover(directory);
-
-            if (gitDirectory != null)
-            {
-                return gitDirectory.TrimEnd(Path.DirectorySeparatorChar);
-            }
-
-            return null;
-        }
-
-
         public IRepository GetRepository(string gitDirectory)
         {
             try
diff --git a/src/GitVersionCore/Helpers/IFileSystem.cs b/src/GitVersionCore/Helpers/IFileSystem.cs
@@ -18,7 +18,6 @@ public interface IFileSystem
         Stream OpenRead(string path);
         void CreateDirectory(string path);
         long GetLastDirectoryWrite(string path);
-        string TreeWalkForDotGitDir(string directory);
         IRepository GetRepository(string gitDirectory);
     }
 }
diff --git a/src/GitVersionTask/VersionAndBranchFinder.cs b/src/GitVersionTask/VersionAndBranchFinder.cs
@@ -9,6 +9,8 @@
 using GitVersion;
 using GitVersion.Helpers;
 
+using LibGit2Sharp;
+
 using YamlDotNet.Serialization;
 
 public static class VersionAndBranchFinder
@@ -34,7 +36,7 @@ public static bool TryGetVersion(string directory, out VersionVariables versionV
 
     public static VersionVariables GetVersion(string directory, Authentication authentication, bool noFetch, IFileSystem fileSystem)
     {
-        var gitDir = fileSystem.TreeWalkForDotGitDir(directory);
+        var gitDir = Repository.Discover(directory);
         using (var repo = fileSystem.GetRepository(gitDir))
         {
             // Maybe using timestamp in .git/refs directory is enough?

Original file line number	Diff line number	Diff line change
`@@ -11,16 +11,13 @@ public class FileSystemTests`
`11`	`11`	`{`
`12`	`12`	`string workDirectory;`
`13`	`13`	`string gitDirectory;`
`14`		`- IFileSystem fileSystem;`
`15`	`14`
`16`	`15`	`[SetUp]`
`17`	`16`	`public void CreateTemporaryRepository()`
`18`	`17`	`{`
`19`		`- this.fileSystem = new FileSystem();`
`20`	`18`	`workDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());`
`21`	`19`
`22`		`- gitDirectory = Repository.Init(workDirectory)`
`23`		`- .TrimEnd(new[] { Path.DirectorySeparatorChar });`
	`20`	`+ gitDirectory = Repository.Init(workDirectory);`
`24`	`21`
`25`	`22`	`Assert.NotNull(gitDirectory);`
`26`	`23`	`}`
`@@ -34,26 +31,26 @@ public void Cleanup()`
`34`	`31`	`[Test]`
`35`	`32`	`public void From_WorkingDirectory()`
`36`	`33`	`{`
`37`		`- Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(workDirectory));`
	`34`	`+ Assert.AreEqual(gitDirectory, Repository.Discover(workDirectory));`
`38`	`35`	`}`
`39`	`36`
`40`	`37`	`[Test]`
`41`	`38`	`public void From_WorkingDirectory_Parent()`
`42`	`39`	`{`
`43`	`40`	`var parentDirectory = Directory.GetParent(workDirectory).FullName;`
`44`		`- Assert.Null(fileSystem.TreeWalkForDotGitDir(parentDirectory));`
	`41`	`+ Assert.Null(Repository.Discover(parentDirectory));`
`45`	`42`	`}`
`46`	`43`
`47`	`44`	`[Test]`
`48`	`45`	`public void From_GitDirectory()`
`49`	`46`	`{`
`50`		`- Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(gitDirectory));`
	`47`	`+ Assert.AreEqual(gitDirectory, Repository.Discover(gitDirectory));`
`51`	`48`	`}`
`52`	`49`
`53`	`50`	`[Test]`
`54`	`51`	`public void From_RefsDirectory()`
`55`	`52`	`{`
`56`	`53`	`var refsDirectory = Path.Combine(gitDirectory, "refs");`
`57`		`- Assert.AreEqual(gitDirectory, fileSystem.TreeWalkForDotGitDir(refsDirectory));`
	`54`	`+ Assert.AreEqual(gitDirectory, Repository.Discover(refsDirectory));`
`58`	`55`	`}`
`59`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public RemoteRepositoryFixture(Config configuration)`
`26`	`26`	`/// </summary>`
`27`	`27`	`public void InitialiseRepo()`
`28`	`28`	`{`
`29`		`- new GitPreparer(null, null, new Authentication(), false, LocalRepositoryFixture.RepositoryPath, new FileSystem()).Initialise(true, null);`
	`29`	`+ new GitPreparer(null, null, new Authentication(), false, LocalRepositoryFixture.RepositoryPath).Initialise(true, null);`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`static IRepository CreateNewRepository(string path)`
Original file line number	Diff line number	Diff line change
`@@ -93,12 +93,6 @@ public long GetLastDirectoryWrite(string path)`
`93`	`93`	`}`
`94`	`94`
`95`	`95`
`96`		`- public string TreeWalkForDotGitDir(string directory)`
`97`		`- {`
`98`		`- return directory;`
`99`		`- }`
`100`		`-`
`101`		`-`
`102`	`96`	`public IRepository GetRepository(string gitDirectory)`
`103`	`97`	`{`
`104`	`98`	`var repository = Substitute.For<IRepository>();`
Original file line number	Diff line number	Diff line change
`@@ -2,14 +2,15 @@ namespace GitVersion`
`2`	`2`	`{`
`3`	`3`	`using System;`
`4`	`4`	`using System.Linq;`
	`5`	`+`
`5`	`6`	`using GitVersion.Helpers;`
`6`	`7`
`7`	`8`	`public static class ExecuteCore`
`8`	`9`	`{`
`9`	`10`	`public static VersionVariables ExecuteGitVersion(IFileSystem fileSystem, string targetUrl, string dynamicRepositoryLocation, Authentication authentication, string targetBranch, bool noFetch, string workingDirectory, string commitId)`
`10`	`11`	`{`
`11`	`12`	`// Normalise if we are running on build server`
`12`		`- var gitPreparer = new GitPreparer(targetUrl, dynamicRepositoryLocation, authentication, noFetch, workingDirectory, fileSystem);`
	`13`	`+ var gitPreparer = new GitPreparer(targetUrl, dynamicRepositoryLocation, authentication, noFetch, workingDirectory);`
`13`	`14`	`var applicableBuildServers = BuildServerList.GetApplicableBuildServers();`
`14`	`15`	`var buildServer = applicableBuildServers.FirstOrDefault();`
`15`	`16`
`@@ -29,17 +30,21 @@ public static VersionVariables ExecuteGitVersion(IFileSystem fileSystem, string`
`29`	`30`
`30`	`31`	`using (var repo = fileSystem.GetRepository(dotGitDirectory))`
`31`	`32`	`{`
`32`		`- var gitVersionContext = new GitVersionContext(repo, configuration, commitId: commitId);`
	`33`	`+ var gitVersionContext = new GitVersionContext(repo, configuration, commitId : commitId);`
`33`	`34`	`var semanticVersion = versionFinder.FindVersion(gitVersionContext);`
`34`	`35`	`variables = VariableProvider.GetVariablesFor(semanticVersion, gitVersionContext.Configuration, gitVersionContext.IsCurrentCommitTagged);`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`return variables;`
`38`	`39`	`}`
`39`	`40`
`40`		`- private static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch)`
	`41`	`+`
	`42`	`+ static string ResolveCurrentBranch(IBuildServer buildServer, string targetBranch)`
`41`	`43`	`{`
`42`		`- if (buildServer == null) return targetBranch;`
	`44`	`+ if (buildServer == null)`
	`45`	`+ {`
	`46`	`+ return targetBranch;`
	`47`	`+ }`
`43`	`48`
`44`	`49`	`var currentBranch = buildServer.GetCurrentBranch() ?? targetBranch;`
`45`	`50`	`Logger.WriteInfo("Branch from build environment: " + currentBranch);`
Original file line number	Diff line number	Diff line change
`@@ -4,42 +4,35 @@ namespace GitVersion`
`4`	`4`	`using System.IO;`
`5`	`5`	`using System.Linq;`
`6`	`6`
`7`		`- using GitVersion.Helpers;`
`8`		`-`
`9`	`7`	`using LibGit2Sharp;`
`10`	`8`
`11`	`9`	`public class GitPreparer`
`12`	`10`	`{`
`13`		`- string targetUrl;`
`14`		`- string dynamicRepositoryLocation;`
`15`	`11`	`Authentication authentication;`
	`12`	`+ string dynamicRepositoryLocation;`
`16`	`13`	`bool noFetch;`
`17`	`14`	`string targetPath;`
`18`		`- readonly IFileSystem fileSystem;`
	`15`	`+ string targetUrl;`
`19`	`16`
`20`	`17`
`21`		`- public GitPreparer(string targetUrl, string dynamicRepositoryLocation, Authentication authentication, bool noFetch, string targetPath, IFileSystem fileSystem)`
	`18`	`+ public GitPreparer(string targetUrl, string dynamicRepositoryLocation, Authentication authentication, bool noFetch, string targetPath)`
`22`	`19`	`{`
`23`		`- if (fileSystem == null)`
`24`		`- {`
`25`		`- throw new ArgumentNullException("fileSystem");`
`26`		`- }`
`27`		`-`
`28`	`20`	`this.targetUrl = targetUrl;`
`29`	`21`	`this.dynamicRepositoryLocation = dynamicRepositoryLocation;`
`30`	`22`	`this.authentication = authentication;`
`31`	`23`	`this.noFetch = noFetch;`
`32`	`24`	`this.targetPath = targetPath;`
`33`		`- this.fileSystem = fileSystem;`
`34`	`25`	`}`
`35`	`26`
	`27`	`+`
`36`	`28`	`public bool IsDynamicGitRepository`
`37`	`29`	`{`
`38`	`30`	`get { return !string.IsNullOrWhiteSpace(DynamicGitRepositoryPath); }`
`39`	`31`	`}`
`40`	`32`
`41`	`33`	`public string DynamicGitRepositoryPath { get; private set; }`
`42`	`34`
	`35`	`+`
`43`	`36`	`public void Initialise(bool normaliseGitDirectory, string currentBranch)`
`44`	`37`	`{`
`45`	`38`	`if (string.IsNullOrWhiteSpace(targetUrl))`
`@@ -56,6 +49,7 @@ public void Initialise(bool normaliseGitDirectory, string currentBranch)`
`56`	`49`	`DynamicGitRepositoryPath = CreateDynamicRepository(tempRepositoryPath, authentication, targetUrl, currentBranch, noFetch);`
`57`	`50`	`}`
`58`	`51`
	`52`	`+`
`59`	`53`	`static string CalculateTemporaryRepositoryPath(string targetUrl, string dynamicRepositoryLocation)`
`60`	`54`	`{`
`61`	`55`	`var userTemp = dynamicRepositoryLocation ?? Path.GetTempPath();`
`@@ -81,6 +75,7 @@ static string CalculateTemporaryRepositoryPath(string targetUrl, string dynamicR`
`81`	`75`	`return possiblePath;`
`82`	`76`	`}`
`83`	`77`
	`78`	`+`
`84`	`79`	`static bool GitRepoHasMatchingRemote(string possiblePath, string targetUrl)`
`85`	`80`	`{`
`86`	`81`	`try`
`@@ -94,30 +89,34 @@ static bool GitRepoHasMatchingRemote(string possiblePath, string targetUrl)`
`94`	`89`	`{`
`95`	`90`	`return false;`
`96`	`91`	`}`
`97`		`-`
`98`	`92`	`}`
`99`	`93`
	`94`	`+`
`100`	`95`	`public string GetDotGitDirectory()`
`101`	`96`	`{`
`102`	`97`	`if (IsDynamicGitRepository)`
	`98`	`+ {`
`103`	`99`	`return DynamicGitRepositoryPath;`
	`100`	`+ }`
`104`	`101`
`105`		`- return this.fileSystem.TreeWalkForDotGitDir(targetPath);`
	`102`	`+ return Repository.Discover(this.targetPath);`
`106`	`103`	`}`
`107`	`104`
	`105`	`+`
`108`	`106`	`public string GetProjectRootDirectory()`
`109`	`107`	`{`
`110`	`108`	`if (IsDynamicGitRepository)`
`111`	`109`	`return this.targetPath;`
`112`	`110`
`113`		`- var gitDir = fileSystem.TreeWalkForDotGitDir(this.targetPath);`
	`111`	`+ var gitDir = Repository.Discover(this.targetPath);`
`114`	`112`
`115`	`113`	`if (String.IsNullOrEmpty(gitDir))`
`116`	`114`	`throw new DirectoryNotFoundException("Can't find the .git directory in " + targetPath);`
`117`	`115`
`118`	`116`	`return Directory.GetParent(gitDir).FullName;`
`119`	`117`	`}`
`120`	`118`
	`119`	`+`
`121`	`120`	`static string CreateDynamicRepository(string targetPath, Authentication authentication, string repositoryUrl, string targetBranch, bool noFetch)`
`122`	`121`	`{`
`123`	`122`	`if (string.IsNullOrWhiteSpace(targetBranch))`
`@@ -143,7 +142,8 @@ static string CreateDynamicRepository(string targetPath, Authentication authenti`
`143`	`142`	`return gitDirectory;`
`144`	`143`	`}`
`145`	`144`
`146`		`- private static void CloneRepository(string repositoryUrl, string gitDirectory, Authentication authentication)`
	`145`	`+`
	`146`	`+ static void CloneRepository(string repositoryUrl, string gitDirectory, Authentication authentication)`
`147`	`147`	`{`
`148`	`148`	`Credentials credentials = null;`
`149`	`149`	`if (!string.IsNullOrWhiteSpace(authentication.Username) && !string.IsNullOrWhiteSpace(authentication.Password))`
`@@ -162,11 +162,11 @@ private static void CloneRepository(string repositoryUrl, string gitDirectory, A`
`162`	`162`	`try`
`163`	`163`	`{`
`164`	`164`	`Repository.Clone(repositoryUrl, gitDirectory,`
`165`		`- new CloneOptions`
`166`		`- {`
`167`		`- Checkout = false,`
`168`		`- CredentialsProvider = (url, usernameFromUrl, types) => credentials`
`169`		`- });`
	`165`	`+ new CloneOptions`
	`166`	`+ {`
	`167`	`+ Checkout = false,`
	`168`	`+ CredentialsProvider = (url, usernameFromUrl, types) => credentials`
	`169`	`+ });`
`170`	`170`	`}`
`171`	`171`	`catch (LibGit2SharpException ex)`
`172`	`172`	`{`
`@@ -183,7 +183,7 @@ private static void CloneRepository(string repositoryUrl, string gitDirectory, A`
`183`	`183`	`{`
`184`	`184`	`throw new Exception("Not found: The repository was not found");`
`185`	`185`	`}`
`186`		`-`
	`186`	`+`
`187`	`187`	`throw new Exception("There was an unknown problem with the Git repository you provided");`
`188`	`188`	`}`
`189`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ public interface IFileSystem`
`18`	`18`	`Stream OpenRead(string path);`
`19`	`19`	`void CreateDirectory(string path);`
`20`	`20`	`long GetLastDirectoryWrite(string path);`
`21`		`- string TreeWalkForDotGitDir(string directory);`
`22`	`21`	`IRepository GetRepository(string gitDirectory);`
`23`	`22`	`}`
`24`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`using GitVersion;`
`10`	`10`	`using GitVersion.Helpers;`
`11`	`11`
	`12`	`+using LibGit2Sharp;`
	`13`	`+`
`12`	`14`	`using YamlDotNet.Serialization;`
`13`	`15`
`14`	`16`	`public static class VersionAndBranchFinder`
`@@ -34,7 +36,7 @@ public static bool TryGetVersion(string directory, out VersionVariables versionV`
`34`	`36`
`35`	`37`	`public static VersionVariables GetVersion(string directory, Authentication authentication, bool noFetch, IFileSystem fileSystem)`
`36`	`38`	`{`
`37`		`- var gitDir = fileSystem.TreeWalkForDotGitDir(directory);`
	`39`	`+ var gitDir = Repository.Discover(directory);`
`38`	`40`	`using (var repo = fileSystem.GetRepository(gitDir))`
`39`	`41`	`{`
`40`	`42`	`// Maybe using timestamp in .git/refs directory is enough?`