Merge branch 'enhancements/git-install-validation' into enhancements/git-path-view

# Conflicts:
#	src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs

Author: StanleyGoldman

src/GitHub.Api/Git/GitClient.cs

@@ -9,7 +9,8 @@ namespace GitHub.Unity
     interface IGitClient
     {
         Task<NPath> FindGitInstallation();
-        bool ValidateGitInstall(NPath path);
+
+        ITask<bool> ValidateGitInstall(NPath path);
 
         ITask Init(IOutputProcessor<string> processor = null);
 
@@ -152,9 +153,40 @@ private async Task<NPath> LookForSystemGit()
             return path;
         }
 
-        public bool ValidateGitInstall(NPath path)
+        public ITask<bool> ValidateGitInstall(NPath path)
         {
-            return path.FileExists();
+            if (!path.FileExists())
+            {
+                return new FuncTask<bool>(cancellationToken, () => false);
+            }
+
+            SoftwareVersion? gitVersion = null;
+            SoftwareVersion? gitLfsVersion = null;
+
+            var gitVersionTask = new GitVersionTask(cancellationToken);
+            gitVersionTask.Configure(processManager, path.ToString(), 
+                gitVersionTask.ProcessArguments, environment.RepositoryPath);
+
+            var gitLfsVersionTask = new GitLfsVersionTask(cancellationToken);
+            gitLfsVersionTask.Configure(processManager, path.ToString(),
+                gitLfsVersionTask.ProcessArguments, environment.RepositoryPath);
+
+            return gitVersionTask
+                .Then((result, version) => { gitVersion = version; })
+                .Then(gitLfsVersionTask)
+                .Then((result, version) => {
+                    gitLfsVersion = version;
+                }).Then(result => {
+                    if (result)
+                    {
+                        return gitVersion.HasValue &&
+                            gitVersion.Value >= new SoftwareVersion(2, 1, 0) &&
+                            gitLfsVersion.HasValue &&
+                            gitLfsVersion.Value >= new SoftwareVersion(2, 1, 0);
+                    }
+
+                    return false;
+                });
         }
 
         public ITask Init(IOutputProcessor<string> processor = null)

src/GitHub.Api/OutputProcessors/SoftwareVersion.cs

@@ -13,10 +13,72 @@ public SoftwareVersion(int major, int minor, int build)
             Build = build;
         }
 
-        public SoftwareVersion(string major, string minor, string build):
+        public SoftwareVersion(string major, string minor, string build) :
             this(int.Parse(major), int.Parse(minor), int.Parse(build))
         {
-            
+
+        }
+
+        public static bool operator <(SoftwareVersion lhs, SoftwareVersion rhs)
+        {
+            if (lhs.Major < rhs.Major)
+            {
+                return true;
+            }
+
+            if (lhs.Major == rhs.Major)
+            {
+                if (lhs.Minor < rhs.Minor)
+                {
+                    return true;
+                }
+
+                if (lhs.Minor == rhs.Minor)
+                {
+                    if (lhs.Build < rhs.Build)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool operator >(SoftwareVersion lhs, SoftwareVersion rhs)
+        {
+            if (lhs.Major > rhs.Major)
+            {
+                return true;
+            }
+
+            if (lhs.Major == rhs.Major)
+            {
+                if (lhs.Minor > rhs.Minor)
+                {
+                    return true;
+                }
+
+                if (lhs.Minor == rhs.Minor)
+                {
+                    if (lhs.Build > rhs.Build)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public static bool operator <=(SoftwareVersion lhs, SoftwareVersion rhs)
+        {
+            return lhs.Equals(rhs) || lhs < rhs;
+        }
+
+        public static bool operator >=(SoftwareVersion lhs, SoftwareVersion rhs)
+        {
+            return lhs.Equals(rhs) || lhs > rhs;
         }
     }
 }

src/tests/UnitTests/IO/SoftwareVersionTests.cs

@@ -0,0 +1,24 @@
+using FluentAssertions;
+using GitHub.Unity;
+using NUnit.Framework;
+
+namespace UnitTests
+{
+    [TestFixture]
+    class SoftwareVersionTests
+    {
+        [Test]
+        public void LessThanOrEqualTo()
+        {
+            (new SoftwareVersion(1, 1, 0) <= new SoftwareVersion(1, 1, 0)).Should().BeTrue();
+            (new SoftwareVersion(1, 0, 0) <= new SoftwareVersion(1, 1, 0)).Should().BeTrue();
+        }
+
+        [Test]
+        public void LessThan()
+        {
+            (new SoftwareVersion(1, 1, 0) < new SoftwareVersion(1, 1, 0)).Should().BeFalse();
+            (new SoftwareVersion(1, 0, 0) < new SoftwareVersion(1, 1, 0)).Should().BeTrue();
+        }
+    }
+}

src/tests/UnitTests/UnitTests.csproj

@@ -84,6 +84,7 @@
     <Compile Include="Extensions\EnvironmentExtensionTests.cs" />
     <Compile Include="IO\LfsVersionOutputProcessorTests.cs" />
     <Compile Include="IO\LockOutputProcessorTests.cs" />
+    <Compile Include="IO\SoftwareVersionTests.cs" />
     <Compile Include="IO\VersionOutputProcessorTests.cs" />
     <Compile Include="IO\RemoteListOutputProcessorTests.cs" />
     <Compile Include="IO\BaseOutputProcessorTests.cs" />