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,12 +64,48 @@ 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();
                     continue;
                 }
 
+                if (IsSwitch("output", name))
+                {
+                    var outputType = OutputType.Json;
+                    if (!Enum.TryParse(value, true, out outputType))
+                    {
+                        throw new ErrorException(string.Format("Value '{0}' cannot be parsed as output type, please use 'json' or 'buildserver'", value));
+                    }
+
+                    arguments.Output = outputType;
+                    continue;
+                }
+
                 throw new ErrorException(string.Format("Could not parse command line parameter '{0}'.", name));
             }
             return arguments;
@@ -101,13 +137,10 @@ static void EnsureArgumentsEvenCount(List<string> commandLineArguments, List<str
 
         static bool IsHelp(string singleArgument)
         {
-            return (singleArgument == "?") ||
-                   (singleArgument == "/h") ||
-                   (singleArgument == "/help") ||
-                   (singleArgument == "/?") ||
-                   (singleArgument == "-h") ||
-                   (singleArgument == "-help") ||
-                   (singleArgument == "-?");
+            return (singleArgument == "?") || 
+                IsSwitch("h", singleArgument) || 
+                IsSwitch("help", singleArgument) || 
+                IsSwitch("?", singleArgument);
         }
 
         static string[] VersionParts = {"major", "minor", "patch", "long", "short", "nuget"};

GitVersion/Arguments.cs

@@ -1,10 +1,35 @@
 namespace GitVersion
 {
-    class Arguments
+    using System;
+
+    public enum OutputType
     {
+        BuildServer,
+
+        Json
+    }
+
+    public class Arguments
+    {
+        public Arguments()
+        {
+            Username = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_USERNAME");
+            Password = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_PASSWORD");
+            Output = OutputType.Json;
+        }
+
         public string TargetPath;
+
+        public string TargetUrl;
+        public string TargetBranch;
+
+        public string Username;
+        public string Password;
+
         public bool IsHelp;
         public string LogFilePath;
         public string VersionPart;
+
+        public OutputType Output;
     }
 }

GitVersion/BuildServers/BuildServerBase.cs

@@ -0,0 +1,33 @@
+namespace GitVersion
+{
+    using System;
+
+    public abstract class BuildServerBase : IBuildServer
+    {
+        public abstract bool CanApplyToCurrentContext();
+        public abstract void PerformPreProcessingSteps(string gitDirectory);
+        public abstract string GenerateSetVersionMessage(string versionToUseForBuildNumber);
+        public abstract string[] GenerateSetParameterMessage(string name, string value);
+
+        public virtual void WriteIntegration(VersionAndBranch versionAndBranch, Action<string> writer)
+        {
+            if (versionAndBranch == null)
+            {
+                return;
+            }
+
+            if (writer == null)
+            {
+                return;
+            }
+
+            writer(string.Format("Executing GenerateSetVersionMessage for '{0}'.", GetType().Name));
+            writer(GenerateSetVersionMessage(versionAndBranch.GenerateSemVer()));
+            writer(string.Format("Executing GenerateBuildLogOutput for '{0}'.", GetType().Name));
+            foreach (var buildParameter in BuildOutputFormatter.GenerateBuildLogOutput(versionAndBranch, this))
+            {
+                writer(buildParameter);
+            }
+        }
+    }
+}

GitVersion/BuildServers/BuildServerList.cs

@@ -5,34 +5,50 @@
 
     public static class BuildServerList
     {
-        public static List<IBuildServer> BuildServers = new List<IBuildServer>
-            {
-                new ContinuaCi(),
-                new TeamCity()
-            };
+        static List<IBuildServer> BuildServers;
 
-        public static Func<IEnumerable<IBuildServer>> Selector = () => DefaultSelector();
+        public static Func<Arguments, IEnumerable<IBuildServer>> Selector = arguments => DefaultSelector(arguments);
 
         public static void ResetSelector()
         {
             Selector = DefaultSelector;
         }
 
-        public static IEnumerable<IBuildServer> GetApplicableBuildServers()
+        public static IEnumerable<IBuildServer> GetApplicableBuildServers(Arguments arguments)
         {
-            return Selector();
+            return Selector(arguments);
         }
 
-        static IEnumerable<IBuildServer> DefaultSelector()
+        static IEnumerable<IBuildServer> DefaultSelector(Arguments arguments)
         {
+            if (BuildServers == null)
+            {
+                BuildServers = new List<IBuildServer>
+                {
+                    new ContinuaCi(arguments),
+                    new TeamCity(arguments)
+                };
+            }
+
+            var buildServices = new List<IBuildServer>();
+
             foreach (var buildServer in BuildServers)
             {
-                if (buildServer.CanApplyToCurrentContext())
+                try
+                {
+                    if (buildServer.CanApplyToCurrentContext())
+                    {
+                        Logger.WriteInfo(string.Format("Applicable build agent found: '{0}'.", buildServer.GetType().Name));
+                        buildServices.Add(buildServer);
+                    }
+                }
+                catch (Exception ex)
                 {
-                    Logger.WriteInfo(string.Format("Applicable build agent found: '{0}'.", buildServer.GetType().Name));
-                    yield return buildServer;
+                    Logger.WriteWarning(string.Format("Failed to check build server '{0}': {1}", buildServer.GetType().Name, ex.Message));
                 }
             }
+
+            return buildServices;
         }
     }
 }

GitVersion/BuildServers/ContinuaCi.cs

@@ -2,38 +2,61 @@
 {
     using Microsoft.Win32;
 
-    public class ContinuaCi : IBuildServer
+    public class ContinuaCi : BuildServerBase
     {
-        public bool CanApplyToCurrentContext()
+        readonly Arguments _arguments;
+
+        public ContinuaCi(Arguments arguments)
+        {
+            _arguments = arguments;
+        }
+
+        public override bool CanApplyToCurrentContext()
         {
-            using (var registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\VSoft Technologies\\Continua CI Agent"))
+            const string KeyName = @"Software\VSoft Technologies\Continua CI Agent";
+
+            if (RegistryKeyExists(KeyName, RegistryView.Registry32))
+            {
+                return true;
+            }
+
+            if (RegistryKeyExists(KeyName, RegistryView.Registry64))
             {
-                return registryKey != null;
+                return true;
             }
+
+            return false;
         }
 
-        public void PerformPreProcessingSteps(string gitDirectory)
+        public override void PerformPreProcessingSteps(string gitDirectory)
         {
             if (string.IsNullOrEmpty(gitDirectory))
             {
                 throw new ErrorException("Failed to find .git directory on agent");
             }
 
-            GitHelper.NormalizeGitDirectory(gitDirectory);
+            GitHelper.NormalizeGitDirectory(gitDirectory, _arguments);
         }
 
-        public string[] GenerateSetParameterMessage(string name, string value)
+        public override string[] GenerateSetParameterMessage(string name, string value)
         {
-            return new []
+            return new[]
             {
-                string.Format("@@continua[setVariable name='GitVersion.{0}' value='{1}']", name, value)
+                string.Format("@@continua[setVariable name='GitVersion_{0}' value='{1}']", name, value)
             };
         }
 
-        public string GenerateSetVersionMessage(string versionToUseForBuildNumber)
+        public override string GenerateSetVersionMessage(string versionToUseForBuildNumber)
         {
             return string.Format("@@continua[setBuildVersion value='{0}']", versionToUseForBuildNumber);
         }
-    }
 
+        private static bool RegistryKeyExists(string keyName, RegistryView registryView)
+        {
+            var localKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, registryView);
+            localKey = localKey.OpenSubKey(keyName);
+
+            return localKey != null;
+        }
+    }
 }

GitVersion/BuildServers/GitHelper.cs

@@ -1,12 +1,11 @@
 namespace GitVersion
 {
-    using System;
     using System.Linq;
     using LibGit2Sharp;
 
     public static class GitHelper
     {
-        public static void NormalizeGitDirectory(string gitDirectory)
+        public static void NormalizeGitDirectory(string gitDirectory, Arguments arguments)
         {
             using (var repo = new Repository(gitDirectory))
             {
@@ -15,7 +14,7 @@ public static void NormalizeGitDirectory(string gitDirectory)
                 Logger.WriteInfo(string.Format("Fetching from remote '{0}' using the following refspecs: {1}.",
                     remote.Name, string.Join(", ", remote.FetchRefSpecs.Select(r => r.Specification))));
 
-                var fetchOptions = BuildFetchOptions();
+                var fetchOptions = BuildFetchOptions(arguments.Username, arguments.Password);
                 repo.Network.Fetch(remote, fetchOptions);
 
                 CreateMissingLocalBranchesFromRemoteTrackingOnes(repo, remote.Name);
@@ -32,16 +31,17 @@ public static void NormalizeGitDirectory(string gitDirectory)
             }
         }
 
-        static FetchOptions BuildFetchOptions()
+        static FetchOptions BuildFetchOptions(string username, string password)
         {
-            var username = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_USERNAME");
-            var password = Environment.GetEnvironmentVariable("GITVERSION_REMOTE_PASSWORD");
-
             var fetchOptions = new FetchOptions();
 
             if (!string.IsNullOrEmpty(username))
             {
-                fetchOptions.Credentials = new Credentials { Username = username, Password = password };
+                fetchOptions.Credentials = new Credentials
+                {
+                    Username = username, 
+                    Password = password
+                };
             }
 
             return fetchOptions;

GitVersion/BuildServers/IBuildServer.cs

@@ -1,10 +1,15 @@
 namespace GitVersion
 {
+    using System;
+
     public interface IBuildServer
     {
         bool CanApplyToCurrentContext();
         void PerformPreProcessingSteps(string gitDirectory);
         string GenerateSetVersionMessage(string versionToUseForBuildNumber);
         string[] GenerateSetParameterMessage(string name, string value);
+
+        void WriteIntegration(VersionAndBranch versionAndBranch, Action<string> writer);
     }
+
 }