Added support for remote repositories (with and without authentication)

GitVersion/ArgumentParser.cs

@@ -16,9 +16,9 @@ public static Arguments ParseArguments(List<string> commandLineArguments)
             if (commandLineArguments.Count == 0)
             {
                 return new Arguments
-                    {
-                        TargetPath = Environment.CurrentDirectory
-                    };
+                {
+                    TargetPath = Environment.CurrentDirectory
+                };
             }
 
             var firstArgument = commandLineArguments.First();
@@ -33,9 +33,9 @@ public static Arguments ParseArguments(List<string> commandLineArguments)
             if (commandLineArguments.Count == 1)
             {
                 return new Arguments
-                    {
-                        TargetPath = firstArgument
-                    };
+                {
+                    TargetPath = firstArgument
+                };
             }
 
             List<string> namedArguments;
@@ -64,6 +64,30 @@ public static Arguments ParseArguments(List<string> commandLineArguments)
                     continue;
                 }
 
+                if (IsSwitch("url", name))
+                {
+                    arguments.TargetUrl = value;
+                    continue;
+                }
+
+                if (IsSwitch("b", name))
+                {
+                    arguments.TargetBranch = value;
+                    continue;
+                }
+
+                if (IsSwitch("u", name))
+                {
+                    arguments.Username = value;
+                    continue;
+                }
+
+                if (IsSwitch("p", name))
+                {
+                    arguments.Password = value;
+                    continue;
+                }
+
                 if ((IsSwitch("v", name)) && VersionParts.Contains(value.ToLower()))
                 {
                     arguments.VersionPart = value.ToLower();

GitVersion/Arguments.cs

@@ -3,6 +3,13 @@ namespace GitVersion
     class Arguments
     {
         public string TargetPath;
+
+        public string TargetUrl;
+        public string TargetBranch;
+
+        public string Username;
+        public string Password;
+
         public bool IsHelp;
         public string LogFilePath;
         public string VersionPart;

GitVersion/BuildServers/GitHelper.cs

@@ -34,6 +34,7 @@ public static void NormalizeGitDirectory(string gitDirectory)
 
         static FetchOptions BuildFetchOptions()
         {
+            // TODO: Respect username/password of arguments?
             var username = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_USERNAME");
             var password = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_PASSWORD");
 

GitVersion/GitFlow/BranchFinders/OptionallyTaggedBranchVersionFinderBase.cs

@@ -142,8 +142,7 @@ int NumberOfCommitsInBranchNotKnownFromBaseBranch(
             BranchType branchType,
             string baseBranchName)
         {
-            var baseTip = repo.Branches[baseBranchName].Tip;
-
+            var baseTip = repo.FindBranch(baseBranchName).Tip;
             if (branch.Tip == baseTip)
             {
                 // The branch bears no additional commit

GitVersion/GitPreparer.cs

@@ -0,0 +1,106 @@
+namespace GitVersion
+{
+    using System.IO;
+    using LibGit2Sharp;
+
+    public class GitPreparer
+    {
+        public GitPreparer(string targetPath, string url, string branchName, string username, string password)
+        {
+            TargetPath = targetPath;
+            Url = url;
+            BranchName = branchName;
+            Username = username;
+            Password = password;
+        }
+
+        public string TargetPath { get; private set; }
+
+        public string Url { get; private set; }
+
+        public string BranchName { get; private set; }
+
+        public string Username { get; private set; }
+
+        public string Password { get; private set; }
+
+        public bool IsDynamicGitRepository
+        {
+            get { return !string.IsNullOrWhiteSpace(DynamicGitRepositoryPath); }
+        }
+
+        public string DynamicGitRepositoryPath { get; private set; }
+
+        public string Prepare()
+        {
+            var gitPath = TargetPath;
+
+            if (!string.IsNullOrWhiteSpace(Url))
+            {
+                gitPath = GetGitInfoFromUrl();
+            }
+
+            return GitDirFinder.TreeWalkForGitDir(gitPath);
+        }
+
+        private string GetGitInfoFromUrl()
+        {
+            var gitDirectory = Path.Combine(TargetPath, "_dynamicrepository", ".git");
+            if (Directory.Exists(gitDirectory))
+            {
+                Logger.WriteInfo(string.Format("Deleting existing .git folder from '{0}' to force new checkout from url", gitDirectory));
+
+                DeleteHelper.DeleteGitRepository(gitDirectory);
+            }
+
+            Credentials credentials = null;
+            if (!string.IsNullOrWhiteSpace(Username) && !string.IsNullOrWhiteSpace(Password))
+            {
+                Logger.WriteInfo(string.Format("Setting up credentials using name '{0}'", Username));
+
+                credentials = new Credentials()
+                {
+                    Username = Username,
+                    Password = Password
+                };
+            }
+
+            Logger.WriteInfo(string.Format("Retrieving git info from url '{0}'", Url));
+
+            Repository.Clone(Url, gitDirectory, checkout: false, credentials: credentials);
+
+            if (!string.IsNullOrWhiteSpace(BranchName))
+            {
+                // Normalize (download branches) before using the branch
+                GitHelper.NormalizeGitDirectory(gitDirectory);
+
+                using (var repository = new Repository(gitDirectory))
+                {
+                    var targetBranchName = string.Format("refs/heads/{0}", BranchName);
+                    if (!string.Equals(repository.Head.CanonicalName, targetBranchName))
+                    {
+                        Logger.WriteInfo(string.Format("Switching to branch '{0}'", BranchName));
+
+                        var branch = repository.FindBranch(BranchName);
+                        if ((branch != null) && !branch.IsCurrentRepositoryHead)
+                        {
+                            // Option 1: checkout (slow)
+                            //repository.Checkout(branch, CheckoutModifiers.Force, null, null);
+
+                            // Option 2: add head refs
+                            //var finalName = string.Format("refs/heads/{0}", BranchName);
+                            //repository.Refs.Add("HEAD", finalName, true);
+
+                            // Option 3: replace head
+                            repository.Refs.UpdateTarget("HEAD", branch.CanonicalName);
+                        }
+                    }
+                }
+            }
+
+            DynamicGitRepositoryPath = gitDirectory;
+
+            return gitDirectory;
+        }
+    }
+}

GitVersion/GitVersion.csproj

@@ -68,6 +68,8 @@
     <Compile Include="GitHubFlow\LastTaggedReleaseFinder.cs" />
     <Compile Include="GitHubFlow\NextSemverCalculator.cs" />
     <Compile Include="GitHubFlow\NextVersionTxtFileFinder.cs" />
+    <Compile Include="GitPreparer.cs" />
+    <Compile Include="Helpers\DeleteHelper.cs" />
     <Compile Include="OutputFormatters\BuildOutputFormatter.cs" />
     <Compile Include="BuildServers\BuildServerList.cs" />
     <Compile Include="BuildServers\ContinuaCi.cs" />

GitVersion/HelpWriter.cs

@@ -11,8 +11,12 @@ public static void Write()
 
 GitVersion [path] [/l logFilePath]
 
-	path	The directory containing .git. If not defined current directory is used.
-	/l	Path to logfile.
+    path    The directory containing .git. If not defined current directory is used.
+    /url    Url to remote git repository.
+    /b      Name of the branch to use on the remote repository, must be used in combination with /url.
+    /u      Username in case authentication is required.
+    /p      Password in case authentication is required.
+    /l      Path to logfile.
 ";
             Console.Write(message);
         }

GitVersion/Helpers/DeleteHelper.cs

@@ -0,0 +1,27 @@
+namespace GitVersion
+{
+    using System.IO;
+
+    public static class DeleteHelper
+    {
+        public static void DeleteGitRepository(string directory)
+        {
+            if (string.IsNullOrEmpty(directory))
+            {
+                return;
+            }
+
+            foreach (var fileName in Directory.GetFiles(directory, "*.*", SearchOption.AllDirectories))
+            {
+                var fileInfo = new FileInfo(fileName)
+                {
+                    IsReadOnly = false
+                };
+
+                fileInfo.Delete();
+            }
+
+            Directory.Delete(directory, true);
+        }
+    }
+}

GitVersion/LibGitExtensions.cs

@@ -30,8 +30,8 @@ public static Branch FindBranch(this IRepository repository, string branchName)
                 return exact;
             }
 
-            return repository.Branches.FirstOrDefault(x => x.Name == "origin/"+branchName);
-         }
+            return repository.Branches.FirstOrDefault(x => x.Name == "origin/" + branchName);
+        }
 
         public static SemanticVersion NewestSemVerTag(this IRepository repository, Commit commit)
         {
@@ -43,6 +43,7 @@ public static SemanticVersion NewestSemVerTag(this IRepository repository, Commi
                     return version;
                 }
             }
+
             return null;
         }
 
@@ -67,7 +68,7 @@ public static GitObject PeeledTarget(this Tag tag)
 
             while (target is TagAnnotation)
             {
-                target = ((TagAnnotation) (target)).Target;
+                target = ((TagAnnotation)(target)).Target;
             }
 
             return target;