GH-1876, object reference not set to an instance of object

arturcic · arturcic · commit e09622c19df4 · 2019-11-05T23:51:31.000+02:00
diff --git a/src/GitVersionCore.Tests/GitVersionExecutorTests.cs b/src/GitVersionCore.Tests/GitVersionExecutorTests.cs
@@ -76,7 +76,7 @@ public void CacheKeySameAfterReNormalizing()
         }
 
         [Test]
-        public void GitPreparerShouldFailWhenTargetPathNotInitialized()
+        public void GitPreparerShouldNotFailWhenTargetPathNotInitialized()
         {
             RepositoryScope((fixture, vv) =>
             {
@@ -88,10 +88,6 @@ public void GitPreparerShouldFailWhenTargetPathNotInitialized()
                     TargetPath = null
                 };
                 var options = Options.Create(arguments);
-                Should.Throw<NullReferenceException>(() => new GitPreparer(log, environment, options));
-
-                arguments.TargetPath = fixture.RepositoryPath;
-
                 Should.NotThrow(() => new GitPreparer(log, environment, options));
             });
         }
@@ -413,7 +409,7 @@ public void GetProjectRootDirectoryWorkingDirectoryWithWorktree()
 
                     var gitPreparer = new GitPreparer(log, environment, Options.Create(arguments));
 
-                    gitPreparer.GetProjectRootDirectory().TrimEnd('/', '\\').ShouldBe(worktreePath);
+                    gitPreparer.GetProjectRootDirectoryInternal().TrimEnd('/', '\\').ShouldBe(worktreePath);
                 }
                 finally
                 {
@@ -437,7 +433,7 @@ public void GetProjectRootDirectoryNoWorktree()
 
                 var gitPreparer = new GitPreparer(log, environment, Options.Create(arguments));
                 var expectedPath = fixture.RepositoryPath.TrimEnd('/', '\\');
-                gitPreparer.GetProjectRootDirectory().TrimEnd('/', '\\').ShouldBe(expectedPath);
+                gitPreparer.GetProjectRootDirectoryInternal().TrimEnd('/', '\\').ShouldBe(expectedPath);
             });
         }
 
diff --git a/src/GitVersionCore/Cache/GitVersionCacheKeyFactory.cs b/src/GitVersionCore/Cache/GitVersionCacheKeyFactory.cs
@@ -6,6 +6,7 @@
 using System.Text;
 using GitVersion.Configuration;
 using GitVersion.Logging;
+using GitVersion.Extensions;
 
 namespace GitVersion.Cache
 {
@@ -124,7 +125,8 @@ private static List<string> CalculateDirectoryContents(ILog log, string root)
 
         private static string GetRepositorySnapshotHash(IGitPreparer gitPreparer)
         {
-            var repositorySnapshot = gitPreparer.WithRepository(repo => {
+            var repositorySnapshot = gitPreparer.GetDotGitDirectory().WithRepository(repo =>
+            {
                 var head = repo.Head;
                 if (head.Tip == null)
                 {
diff --git a/src/GitVersionCore/Configuration/ConfigFileLocator.cs b/src/GitVersionCore/Configuration/ConfigFileLocator.cs
@@ -23,7 +23,7 @@ protected ConfigFileLocator(IFileSystem fileSystem, ILog log)
 
         public string SelectConfigFilePath(IGitPreparer gitPreparer)
         {
-            var workingDirectory = gitPreparer.WorkingDirectory;
+            var workingDirectory = gitPreparer.GetWorkingDirectory();
             var projectRootDirectory = gitPreparer.GetProjectRootDirectory();
 
             if (HasConfigFileAt(workingDirectory))
@@ -50,14 +50,14 @@ public Config ReadConfig(string workingDirectory)
 
         public void Verify(IGitPreparer gitPreparer)
         {
-            if (!string.IsNullOrWhiteSpace(gitPreparer.TargetUrl))
+            if (!string.IsNullOrWhiteSpace(gitPreparer.GetTargetUrl()))
             {
                 // Assuming this is a dynamic repository. At this stage it's unsure whether we have
                 // any .git info so we need to skip verification
                 return;
             }
 
-            var workingDirectory = gitPreparer.WorkingDirectory;
+            var workingDirectory = gitPreparer.GetWorkingDirectory();
             var projectRootDirectory = gitPreparer.GetProjectRootDirectory();
 
             Verify(workingDirectory, projectRootDirectory);
diff --git a/src/GitVersionCore/Configuration/ConfigFileLocatorFactory.cs b/src/GitVersionCore/Configuration/ConfigFileLocatorFactory.cs
@@ -14,7 +14,7 @@ public ConfigFileLocatorFactory(IFileSystem fileSystem, ILog log, IOptions<Argum
         {
             this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
             this.log = log ?? throw new ArgumentNullException(nameof(log));
-            this.options = options ?? throw new ArgumentNullException(nameof(fileSystem));
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public IConfigFileLocator Create()
@@ -24,4 +24,4 @@ public IConfigFileLocator Create()
                 : new NamedConfigFileLocator(fileSystem, log, options);
         }
     }
-}
+}
diff --git a/src/GitVersionCore/Configuration/ConfigProvider.cs b/src/GitVersionCore/Configuration/ConfigProvider.cs
@@ -24,7 +24,7 @@ public ConfigProvider(IFileSystem fileSystem, ILog log, IConfigFileLocator confi
 
         public Config Provide(bool applyDefaults = true, Config overrideConfig = null)
         {
-            var workingDirectory = gitPreparer.WorkingDirectory;
+            var workingDirectory = gitPreparer.GetWorkingDirectory();
             var projectRootDirectory = gitPreparer.GetProjectRootDirectory();
 
             var rootDirectory = configFileLocator.HasConfigFileAt(workingDirectory) ? workingDirectory : projectRootDirectory;
diff --git a/src/GitVersionCore/Configuration/NamedConfigFileLocator.cs b/src/GitVersionCore/Configuration/NamedConfigFileLocator.cs
@@ -8,14 +8,14 @@ namespace GitVersion.Configuration
 {
     public class NamedConfigFileLocator : ConfigFileLocator
     {
+        private readonly IOptions<Arguments> options;
+
         public NamedConfigFileLocator(IFileSystem fileSystem, ILog log, IOptions<Arguments> options) : base(fileSystem, log)
         {
-            var filePath = options.Value.ConfigFile;
-            if (string.IsNullOrEmpty(filePath)) throw new ArgumentNullException(nameof(filePath), "Empty file path provided!");
-            FilePath = filePath;
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
-        public string FilePath { get; }
+        public string FilePath => options.Value.ConfigFile;
 
         public override bool HasConfigFileAt(string workingDirectory) =>
             FileSystem.Exists(Path.Combine(workingDirectory, FilePath));
diff --git a/src/GitVersionCore/Extensions/LibGitExtensions.cs b/src/GitVersionCore/Extensions/LibGitExtensions.cs
@@ -11,6 +11,12 @@ namespace GitVersion.Extensions
 {
     public static class LibGitExtensions
     {
+        public static TResult WithRepository<TResult>(this string dotGitDirectory, Func<IRepository, TResult> action)
+        {
+            using var repo = new Repository(dotGitDirectory);
+            return action(repo);
+        }
+
         public static DateTimeOffset When(this Commit commit)
         {
             return commit.Committer.When;
diff --git a/src/GitVersionCore/GitPreparer.cs b/src/GitVersionCore/GitPreparer.cs
@@ -12,36 +12,43 @@ public class GitPreparer : IGitPreparer
     {
         private readonly ILog log;
         private readonly IEnvironment environment;
-        private readonly string dynamicRepositoryLocation;
-        private readonly Arguments arguments;
+        private readonly IOptions<Arguments> options;
 
         private const string DefaultRemoteName = "origin";
-        private string dynamicGitRepositoryPath;
+        private string dotGitDirectory;
+        private string projectRootDirectory;
+
+        public string GetTargetUrl() => options.Value.TargetUrl;
+
+        public string GetWorkingDirectory() => options.Value.TargetPath.TrimEnd('/', '\\');
+
+        public string GetDotGitDirectory() => dotGitDirectory ??= GetDotGitDirectoryInternal();
+
+        public string GetProjectRootDirectory() => projectRootDirectory ??= GetProjectRootDirectoryInternal();
+
+        private bool IsDynamicGitRepository => !string.IsNullOrWhiteSpace(DynamicGitRepositoryPath);
+        private string DynamicGitRepositoryPath;
 
         public GitPreparer(ILog log, IEnvironment environment, IOptions<Arguments> options)
         {
             this.log = log ?? throw new ArgumentNullException(nameof(log));
-            this.environment = environment;
-            arguments = options.Value;
-
-            TargetUrl = arguments.TargetUrl;
-            WorkingDirectory = arguments.TargetPath.TrimEnd('/', '\\');
-
-            dynamicRepositoryLocation = arguments.DynamicRepositoryLocation;
+            this.environment = environment ?? throw new ArgumentNullException(nameof(environment));
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public void Prepare(bool normalizeGitDirectory, string currentBranch, bool shouldCleanUpRemotes = false)
         {
+            var arguments = options.Value;
             var authentication = new AuthenticationInfo
             {
                 Username = arguments.Authentication?.Username,
                 Password = arguments.Authentication?.Password
             };
-            if (!string.IsNullOrWhiteSpace(TargetUrl))
+            if (!string.IsNullOrWhiteSpace(GetTargetUrl()))
             {
-                var tempRepositoryPath = CalculateTemporaryRepositoryPath(TargetUrl, dynamicRepositoryLocation);
+                var tempRepositoryPath = CalculateTemporaryRepositoryPath(GetTargetUrl(), arguments.DynamicRepositoryLocation);
 
-                dynamicGitRepositoryPath = CreateDynamicRepository(tempRepositoryPath, authentication, TargetUrl, currentBranch);
+                DynamicGitRepositoryPath = CreateDynamicRepository(tempRepositoryPath, authentication, GetTargetUrl(), currentBranch);
             }
             else
             {
@@ -52,62 +59,49 @@ public void Prepare(bool normalizeGitDirectory, string currentBranch, bool shoul
                         CleanupDuplicateOrigin();
                     }
 
-                    NormalizeGitDirectory(authentication, currentBranch, GetDotGitDirectory(), IsDynamicGitRepository());
+                    NormalizeGitDirectory(authentication, currentBranch, GetDotGitDirectoryInternal(), IsDynamicGitRepository);
                 }
             }
         }
 
-        public TResult WithRepository<TResult>(Func<IRepository, TResult> action)
+        private string GetDotGitDirectoryInternal()
         {
-            using IRepository repo = new Repository(GetDotGitDirectory());
-            return action(repo);
-        }
-        
-        public string GetDotGitDirectory()
-        {
-            var dotGitDirectory = IsDynamicGitRepository() ? dynamicGitRepositoryPath : Repository.Discover(WorkingDirectory);
-
-            dotGitDirectory = dotGitDirectory?.TrimEnd('/', '\\');
-            if (string.IsNullOrEmpty(dotGitDirectory))
-                throw new DirectoryNotFoundException("Can't find the .git directory in " + WorkingDirectory);
+            var gitDirectory = IsDynamicGitRepository ? DynamicGitRepositoryPath : Repository.Discover(GetWorkingDirectory());
 
-            if (dotGitDirectory.Contains(Path.Combine(".git", "worktrees")))
-                return Directory.GetParent(Directory.GetParent(dotGitDirectory).FullName).FullName;
+            gitDirectory = gitDirectory?.TrimEnd('/', '\\');
+            if (string.IsNullOrEmpty(gitDirectory))
+                throw new DirectoryNotFoundException("Can't find the .git directory in " + gitDirectory);
 
-            return dotGitDirectory;
+            return gitDirectory.Contains(Path.Combine(".git", "worktrees"))
+                ? Directory.GetParent(Directory.GetParent(gitDirectory).FullName).FullName
+                : gitDirectory;
         }
 
-        public string GetProjectRootDirectory()
+        public string GetProjectRootDirectoryInternal()
         {
-            log.Info($"IsDynamicGitRepository: {IsDynamicGitRepository()}");
-            if (IsDynamicGitRepository())
+            log.Info($"IsDynamicGitRepository: {IsDynamicGitRepository}");
+            if (IsDynamicGitRepository)
             {
-                log.Info($"Returning Project Root as {WorkingDirectory}");
-                return WorkingDirectory;
+                log.Info($"Returning Project Root as {GetWorkingDirectory()}");
+                return GetWorkingDirectory();
             }
 
-            var dotGitDirectory = Repository.Discover(WorkingDirectory);
+            var dotGitDirectory = Repository.Discover(GetWorkingDirectory());
 
             if (string.IsNullOrEmpty(dotGitDirectory))
-                throw new DirectoryNotFoundException($"Can't find the .git directory in {WorkingDirectory}");
+                throw new DirectoryNotFoundException($"Can't find the .git directory in {dotGitDirectory}");
 
             using var repo = new Repository(dotGitDirectory);
             var result = repo.Info.WorkingDirectory;
             log.Info($"Returning Project Root from DotGitDirectory: {dotGitDirectory} - {result}");
             return result;
         }
 
-        public string TargetUrl { get; }
-
-        public string WorkingDirectory { get; }
-
-        private bool IsDynamicGitRepository() => !string.IsNullOrWhiteSpace(dynamicGitRepositoryPath);
-
         private void CleanupDuplicateOrigin()
         {
             var remoteToKeep = DefaultRemoteName;
 
-            using var repo = new Repository(GetDotGitDirectory());
+            using var repo = new Repository(GetDotGitDirectoryInternal());
 
             // check that we have a remote that matches defaultRemoteName if not take the first remote
             if (!repo.Network.Remotes.Any(remote => remote.Name.Equals(DefaultRemoteName, StringComparison.InvariantCultureIgnoreCase)))
@@ -193,7 +187,7 @@ private void NormalizeGitDirectory(AuthenticationInfo auth, string targetBranch,
             using (log.IndentLog($"Normalizing git directory for branch '{targetBranch}'"))
             {
                 // Normalize (download branches) before using the branch
-                GitRepositoryHelper.NormalizeGitDirectory(log, environment, gitDirectory, auth, arguments.NoFetch, targetBranch, isDynamicRepository);
+                GitRepositoryHelper.NormalizeGitDirectory(log, environment, gitDirectory, auth, options.Value.NoFetch, targetBranch, isDynamicRepository);
             }
         }
 
diff --git a/src/GitVersionCore/GitVersionCalculator.cs b/src/GitVersionCore/GitVersionCalculator.cs
@@ -4,6 +4,7 @@
 using GitVersion.Cache;
 using GitVersion.Logging;
 using Microsoft.Extensions.Options;
+using GitVersion.Extensions;
 
 namespace GitVersion
 {
@@ -18,7 +19,7 @@ public class GitVersionCalculator : IGitVersionCalculator
         private readonly IGitVersionFinder gitVersionFinder;
         private readonly IGitPreparer gitPreparer;
         private readonly IVariableProvider variableProvider;
-        private readonly Arguments arguments;
+        private readonly IOptions<Arguments> options;
 
         public GitVersionCalculator(IFileSystem fileSystem, ILog log, IConfigFileLocator configFileLocator,
             IConfigProvider configProvider,
@@ -34,11 +35,12 @@ public GitVersionCalculator(IFileSystem fileSystem, ILog log, IConfigFileLocator
             this.gitVersionFinder = gitVersionFinder ?? throw new ArgumentNullException(nameof(gitVersionFinder));
             this.gitPreparer = gitPreparer ?? throw new ArgumentNullException(nameof(gitPreparer));
             this.variableProvider = variableProvider ?? throw new ArgumentNullException(nameof(variableProvider));
-            this.arguments = options.Value;
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public VersionVariables CalculateVersionVariables()
         {
+            var arguments = options.Value;
             var buildServer = buildServerResolver.Resolve();
 
             // Normalize if we are running on build server
@@ -119,7 +121,7 @@ private VersionVariables ExecuteInternal(string targetBranch, string commitId, C
         {
             var configuration = configProvider.Provide(overrideConfig: overrideConfig);
 
-            return gitPreparer.WithRepository(repo =>
+            return gitPreparer.GetDotGitDirectory().WithRepository(repo =>
             {
                 var gitVersionContext = new GitVersionContext(repo, log, targetBranch, configuration, commitId: commitId);
                 var semanticVersion = gitVersionFinder.FindVersion(gitVersionContext);
diff --git a/src/GitVersionCore/IGitPreparer.cs b/src/GitVersionCore/IGitPreparer.cs
@@ -1,15 +1,11 @@
-using System;
-using LibGit2Sharp;
-
 namespace GitVersion
 {
     public interface IGitPreparer
     {
         void Prepare(bool normalizeGitDirectory, string currentBranch, bool shouldCleanUpRemotes = false);
-        TResult WithRepository<TResult>(Func<IRepository, TResult> action);
-        string GetDotGitDirectory();
         string GetProjectRootDirectory();
-        string TargetUrl { get; }
-        string WorkingDirectory { get; }
+        string GetDotGitDirectory();
+        string GetTargetUrl();
+        string GetWorkingDirectory();
     }
 }
diff --git a/src/GitVersionExe/ExecCommand.cs b/src/GitVersionExe/ExecCommand.cs
@@ -21,16 +21,16 @@ public class ExecCommand : IExecCommand
         private readonly IBuildServerResolver buildServerResolver;
         private readonly ILog log;
         private readonly IGitVersionCalculator gitVersionCalculator;
-        private readonly Arguments arguments;
+        private readonly IOptions<Arguments> options;
         public static readonly string BuildTool = GetMsBuildToolPath();
 
-        public ExecCommand(IFileSystem fileSystem, IBuildServerResolver buildServerResolver, ILog log, IGitVersionCalculator gitVersionCalculator, IOptions<Arguments> arguments)
+        public ExecCommand(IFileSystem fileSystem, IBuildServerResolver buildServerResolver, ILog log, IGitVersionCalculator gitVersionCalculator, IOptions<Arguments> options)
         {
             this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
             this.buildServerResolver = buildServerResolver ?? throw new ArgumentNullException(nameof(buildServerResolver));
             this.log = log ?? throw new ArgumentNullException(nameof(log));
             this.gitVersionCalculator = gitVersionCalculator ?? throw new ArgumentNullException(nameof(gitVersionCalculator));
-            this.arguments = arguments.Value;
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public void Execute()
@@ -39,6 +39,8 @@ public void Execute()
 
             var variables = gitVersionCalculator.CalculateVersionVariables();
 
+            var arguments = options.Value;
+
             switch (arguments.Output)
             {
                 case OutputType.BuildServer:
diff --git a/src/GitVersionExe/GitVersionApp.cs b/src/GitVersionExe/GitVersionApp.cs
@@ -11,20 +11,22 @@ internal class GitVersionApp : IHostedService
     {
         private readonly IHostApplicationLifetime applicationLifetime;
         private readonly IGitVersionExecutor gitVersionExecutor;
-        private readonly Arguments arguments;
+        private readonly ILog log;
+        private readonly IOptions<Arguments> options;
 
         public GitVersionApp(IHostApplicationLifetime applicationLifetime, IGitVersionExecutor gitVersionExecutor, ILog log, IOptions<Arguments> options)
         {
-            this.arguments = options.Value;
+            this.options = options ?? throw new ArgumentNullException(nameof(options));
             this.applicationLifetime = applicationLifetime ?? throw new ArgumentNullException(nameof(applicationLifetime));
             this.gitVersionExecutor = gitVersionExecutor ?? throw new ArgumentNullException(nameof(gitVersionExecutor));
-
-            log.Verbosity = arguments.Verbosity;
+            this.log = log ?? throw new ArgumentNullException(nameof(log));
         }
         public Task StartAsync(CancellationToken cancellationToken)
         {
             try
             {
+                var arguments = options.Value;
+                log.Verbosity = arguments.Verbosity;
                 gitVersionExecutor.Execute(arguments);
             }
             catch (Exception exception)

Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ public void CacheKeySameAfterReNormalizing()`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`[Test]`
`79`		`- public void GitPreparerShouldFailWhenTargetPathNotInitialized()`
	`79`	`+ public void GitPreparerShouldNotFailWhenTargetPathNotInitialized()`
`80`	`80`	`{`
`81`	`81`	`RepositoryScope((fixture, vv) =>`
`82`	`82`	`{`
`@@ -88,10 +88,6 @@ public void GitPreparerShouldFailWhenTargetPathNotInitialized()`
`88`	`88`	`TargetPath = null`
`89`	`89`	`};`
`90`	`90`	`var options = Options.Create(arguments);`
`91`		`- Should.Throw<NullReferenceException>(() => new GitPreparer(log, environment, options));`
`92`		`-`
`93`		`- arguments.TargetPath = fixture.RepositoryPath;`
`94`		`-`
`95`	`91`	`Should.NotThrow(() => new GitPreparer(log, environment, options));`
`96`	`92`	`});`
`97`	`93`	`}`
`@@ -413,7 +409,7 @@ public void GetProjectRootDirectoryWorkingDirectoryWithWorktree()`
`413`	`409`
`414`	`410`	`var gitPreparer = new GitPreparer(log, environment, Options.Create(arguments));`
`415`	`411`
`416`		`- gitPreparer.GetProjectRootDirectory().TrimEnd('/', '\\').ShouldBe(worktreePath);`
	`412`	`+ gitPreparer.GetProjectRootDirectoryInternal().TrimEnd('/', '\\').ShouldBe(worktreePath);`
`417`	`413`	`}`
`418`	`414`	`finally`
`419`	`415`	`{`
`@@ -437,7 +433,7 @@ public void GetProjectRootDirectoryNoWorktree()`
`437`	`433`
`438`	`434`	`var gitPreparer = new GitPreparer(log, environment, Options.Create(arguments));`
`439`	`435`	`var expectedPath = fixture.RepositoryPath.TrimEnd('/', '\\');`
`440`		`- gitPreparer.GetProjectRootDirectory().TrimEnd('/', '\\').ShouldBe(expectedPath);`
	`436`	`+ gitPreparer.GetProjectRootDirectoryInternal().TrimEnd('/', '\\').ShouldBe(expectedPath);`
`441`	`437`	`});`
`442`	`438`	`}`
`443`	`439`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@`
`6`	`6`	`using System.Text;`
`7`	`7`	`using GitVersion.Configuration;`
`8`	`8`	`using GitVersion.Logging;`
	`9`	`+using GitVersion.Extensions;`
`9`	`10`
`10`	`11`	`namespace GitVersion.Cache`
`11`	`12`	`{`
`@@ -124,7 +125,8 @@ private static List<string> CalculateDirectoryContents(ILog log, string root)`
`124`	`125`
`125`	`126`	`private static string GetRepositorySnapshotHash(IGitPreparer gitPreparer)`
`126`	`127`	`{`
`127`		`- var repositorySnapshot = gitPreparer.WithRepository(repo => {`
	`128`	`+ var repositorySnapshot = gitPreparer.GetDotGitDirectory().WithRepository(repo =>`
	`129`	`+ {`
`128`	`130`	`var head = repo.Head;`
`129`	`131`	`if (head.Tip == null)`
`130`	`132`	`{`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ protected ConfigFileLocator(IFileSystem fileSystem, ILog log)`
`23`	`23`
`24`	`24`	`public string SelectConfigFilePath(IGitPreparer gitPreparer)`
`25`	`25`	`{`
`26`		`- var workingDirectory = gitPreparer.WorkingDirectory;`
	`26`	`+ var workingDirectory = gitPreparer.GetWorkingDirectory();`
`27`	`27`	`var projectRootDirectory = gitPreparer.GetProjectRootDirectory();`
`28`	`28`
`29`	`29`	`if (HasConfigFileAt(workingDirectory))`
`@@ -50,14 +50,14 @@ public Config ReadConfig(string workingDirectory)`
`50`	`50`
`51`	`51`	`public void Verify(IGitPreparer gitPreparer)`
`52`	`52`	`{`
`53`		`- if (!string.IsNullOrWhiteSpace(gitPreparer.TargetUrl))`
	`53`	`+ if (!string.IsNullOrWhiteSpace(gitPreparer.GetTargetUrl()))`
`54`	`54`	`{`
`55`	`55`	`// Assuming this is a dynamic repository. At this stage it's unsure whether we have`
`56`	`56`	`// any .git info so we need to skip verification`
`57`	`57`	`return;`
`58`	`58`	`}`
`59`	`59`
`60`		`- var workingDirectory = gitPreparer.WorkingDirectory;`
	`60`	`+ var workingDirectory = gitPreparer.GetWorkingDirectory();`
`61`	`61`	`var projectRootDirectory = gitPreparer.GetProjectRootDirectory();`
`62`	`62`
`63`	`63`	`Verify(workingDirectory, projectRootDirectory);`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public ConfigFileLocatorFactory(IFileSystem fileSystem, ILog log, IOptions<Argum`
`14`	`14`	`{`
`15`	`15`	`this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));`
`16`	`16`	`this.log = log ?? throw new ArgumentNullException(nameof(log));`
`17`		`- this.options = options ?? throw new ArgumentNullException(nameof(fileSystem));`
	`17`	`+ this.options = options ?? throw new ArgumentNullException(nameof(options));`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public IConfigFileLocator Create()`
`@@ -24,4 +24,4 @@ public IConfigFileLocator Create()`
`24`	`24`	`: new NamedConfigFileLocator(fileSystem, log, options);`
`25`	`25`	`}`
`26`	`26`	`}`
`27`		`-}`
	`27`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public ConfigProvider(IFileSystem fileSystem, ILog log, IConfigFileLocator confi`
`24`	`24`
`25`	`25`	`public Config Provide(bool applyDefaults = true, Config overrideConfig = null)`
`26`	`26`	`{`
`27`		`- var workingDirectory = gitPreparer.WorkingDirectory;`
	`27`	`+ var workingDirectory = gitPreparer.GetWorkingDirectory();`
`28`	`28`	`var projectRootDirectory = gitPreparer.GetProjectRootDirectory();`
`29`	`29`
`30`	`30`	`var rootDirectory = configFileLocator.HasConfigFileAt(workingDirectory) ? workingDirectory : projectRootDirectory;`
Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,14 @@ namespace GitVersion.Configuration`
`8`	`8`	`{`
`9`	`9`	`public class NamedConfigFileLocator : ConfigFileLocator`
`10`	`10`	`{`
	`11`	`+ private readonly IOptions<Arguments> options;`
	`12`	`+`
`11`	`13`	`public NamedConfigFileLocator(IFileSystem fileSystem, ILog log, IOptions<Arguments> options) : base(fileSystem, log)`
`12`	`14`	`{`
`13`		`- var filePath = options.Value.ConfigFile;`
`14`		`- if (string.IsNullOrEmpty(filePath)) throw new ArgumentNullException(nameof(filePath), "Empty file path provided!");`
`15`		`- FilePath = filePath;`
	`15`	`+ this.options = options ?? throw new ArgumentNullException(nameof(options));`
`16`	`16`	`}`
`17`	`17`
`18`		`- public string FilePath { get; }`
	`18`	`+ public string FilePath => options.Value.ConfigFile;`
`19`	`19`
`20`	`20`	`public override bool HasConfigFileAt(string workingDirectory) =>`
`21`	`21`	`FileSystem.Exists(Path.Combine(workingDirectory, FilePath));`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,12 @@ namespace GitVersion.Extensions`
`11`	`11`	`{`
`12`	`12`	`public static class LibGitExtensions`
`13`	`13`	`{`
	`14`	`+ public static TResult WithRepository<TResult>(this string dotGitDirectory, Func<IRepository, TResult> action)`
	`15`	`+ {`
	`16`	`+ using var repo = new Repository(dotGitDirectory);`
	`17`	`+ return action(repo);`
	`18`	`+ }`
	`19`	`+`
`14`	`20`	`public static DateTimeOffset When(this Commit commit)`
`15`	`21`	`{`
`16`	`22`	`return commit.Committer.When;`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,11 @@`
`1`		`-using System;`
`2`		`-using LibGit2Sharp;`
`3`		`-`
`4`	`1`	`namespace GitVersion`
`5`	`2`	`{`
`6`	`3`	`public interface IGitPreparer`
`7`	`4`	`{`
`8`	`5`	`void Prepare(bool normalizeGitDirectory, string currentBranch, bool shouldCleanUpRemotes = false);`
`9`		`- TResult WithRepository<TResult>(Func<IRepository, TResult> action);`
`10`		`- string GetDotGitDirectory();`
`11`	`6`	`string GetProjectRootDirectory();`
`12`		`- string TargetUrl { get; }`
`13`		`- string WorkingDirectory { get; }`
	`7`	`+ string GetDotGitDirectory();`
	`8`	`+ string GetTargetUrl();`
	`9`	`+ string GetWorkingDirectory();`
`14`	`10`	`}`
`15`	`11`	`}`