Merge pull request #37 from github-for-unity/fixes/initialization

Fix the repository detection and initialization

Author: shana

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -3,6 +3,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Octokit;
+using System.Collections.Generic;
 
 namespace GitHub.Unity
 {
@@ -21,12 +22,13 @@ public ApplicationManagerBase(SynchronizationContext synchronizationContext)
             UIScheduler = TaskScheduler.FromCurrentSynchronizationContext();
             ThreadingHelper.MainThreadScheduler = UIScheduler;
             TaskManager = new TaskManager(UIScheduler);
-            // accessing Environment triggers environment initialization if it hasn't happened yet
-            Platform = new Platform(Environment);
         }
 
         protected void Initialize()
         {
+            // accessing Environment triggers environment initialization if it hasn't happened yet
+            Platform = new Platform(Environment);
+
             UserSettings = new UserSettings(Environment);
             LocalSettings = new LocalSettings(Environment);
             SystemSettings = new SystemSettings(Environment);
@@ -38,103 +40,134 @@ protected void Initialize()
             Logging.TracingEnabled = UserSettings.Get(Constants.TraceLoggingKey, false);
             ProcessManager = new ProcessManager(Environment, Platform.GitEnvironment, CancellationToken);
             Platform.Initialize(ProcessManager, TaskManager);
-            GitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
         }
 
-        public virtual ITask Run()
+        public virtual async Task Run(bool firstRun)
         {
-            Logger.Trace("Run");
-
-            var progress = new ProgressReport();
-            return new ActionTask(SetupAndRestart(progress))
-                .Then(new ActionTask(LoadKeychain()));
-        }
+            Logger.Trace("Run - CurrentDirectory {0}", NPath.CurrentDirectory);
 
-        private async Task LoadKeychain()
-        {
-            Logger.Trace("Loading Keychain");
-
-            var firstConnection = Platform.Keychain.Connections.FirstOrDefault();
-            if (firstConnection == null)
+            if (Environment.GitExecutablePath != null)
             {
-                Logger.Trace("No Host Found");
+                GitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
             }
             else
             {
-                Logger.Trace("Loading Connection to Host:\"{0}\"", firstConnection);
-                var keychainAdapter = await Platform.Keychain.Load(firstConnection).SafeAwait();
-                if (keychainAdapter.OctokitCredentials == Credentials.Anonymous)
-                { }
+                var progress = new ProgressReport();
+
+                var gitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
+                var gitSetup = new GitSetup(Environment, CancellationToken);
+                var expectedPath = gitSetup.GitInstallationPath;
+                var setupDone = await gitSetup.SetupIfNeeded(progress.Percentage, progress.Remaining);
+                if (setupDone)
+                    Environment.GitExecutablePath = gitSetup.GitExecutablePath;
+                else
+                    Environment.GitExecutablePath = await LookForGitInstallationPath(gitClient, SystemSettings).SafeAwait();
+
+                GitClient = gitClient;
+
+                Logger.Trace("Environment.GitExecutablePath \"{0}\" Exists:{1}", gitSetup.GitExecutablePath, gitSetup.GitExecutablePath.FileExists());
+
+                if (Environment.IsWindows)
+                {
+                    var credentialHelper = await GitClient.GetConfig("credential.helper", GitConfigSource.Global).StartAwait();
+                    if (string.IsNullOrEmpty(credentialHelper))
+                    {
+                        await GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global).StartAwait();
+                    }
+                }
             }
-        }
 
-        protected abstract string DetermineInstallationPath();
-        protected abstract string GetAssetsPath();
-        protected abstract string GetUnityPath();
+            RestartRepository();
+            InitializeUI();
 
-        public virtual ITask RestartRepository()
-        {
-            return new FuncTask<bool>(TaskManager.Token, _ =>
-            {
-                Environment.Initialize();
+            new ActionTask(CancellationToken, SetupMetrics).Start();
+            new ActionTask(new Task(() => LoadKeychain().Start())).Start();
+            new ActionTask(CancellationToken, RunRepositoryManager).Start();
+        }
 
-                if (Environment.RepositoryPath == null)
-                    return false;
-                return true;
+        public ITask InitializeRepository()
+        {
+            Logger.Trace("Running Repository Initialize");
+
+            var targetPath = NPath.CurrentDirectory;
+
+            var unityYamlMergeExec = Environment.UnityApplication.Parent.Combine("Tools", "UnityYAMLMerge");
+            var yamlMergeCommand = $@"'{unityYamlMergeExec}' merge -p ""$BASE"" ""$REMOTE"" ""$LOCAL"" ""$MERGED""";
+
+            var gitignore = targetPath.Combine(".gitignore");
+            var gitAttrs = targetPath.Combine(".gitattributes");
+            var assetsGitignore = targetPath.Combine("Assets", ".gitignore");
+
+            var filesForInitialCommit = new List<string> { gitignore, gitAttrs, assetsGitignore };
+
+            var task = 
+                GitClient.Init()
+                .Then(GitClient.SetConfig("merge.unityyamlmerge.cmd", yamlMergeCommand, GitConfigSource.Local))
+                .Then(GitClient.SetConfig("merge.unityyamlmerge.trustExitCode", "false", GitConfigSource.Local))
+                .Then(GitClient.LfsInstall())
+                .ThenInUI(SetProjectToTextSerialization)
+                .Then(new ActionTask(CancellationToken, _ => {
+                    AssemblyResources.ToFile(ResourceType.Generic, ".gitignore", targetPath);
+                    AssemblyResources.ToFile(ResourceType.Generic, ".gitattributes", targetPath);
+
+                    assetsGitignore.CreateFile();
+                }))
+                .Then(GitClient.Add(filesForInitialCommit))
+                .Then(GitClient.Commit("Initial commit", null))
+                .Then(RestartRepository)
+                .ThenInUI(InitializeUI)
+                .Then(RunRepositoryManager);
+            return task;
+        }
 
-            })
-            .Defer(async s =>
+        public void RestartRepository()
+        {
+            Environment.InitializeRepository();
+            if (Environment.RepositoryPath != null)
             {
-                if (!s)
-                    return false;
-
                 var repositoryPathConfiguration = new RepositoryPathConfiguration(Environment.RepositoryPath);
                 var gitConfig = new GitConfig(repositoryPathConfiguration.DotGitConfig);
 
                 var repositoryWatcher = new RepositoryWatcher(Platform, repositoryPathConfiguration, TaskManager.Token);
                 repositoryManager = new RepositoryManager(Platform, TaskManager, UsageTracker, gitConfig, repositoryWatcher,
                         GitClient, repositoryPathConfiguration, TaskManager.Token);
-
-                await repositoryManager.Initialize().SafeAwait();
                 Environment.Repository = repositoryManager.Repository;
                 Logger.Trace($"Got a repository? {Environment.Repository}");
-                repositoryManager.Start();
-                return true;
-            })
-            .Finally((_, __) => { });
+            }
         }
 
-        private async Task SetupAndRestart(ProgressReport progress)
+        private void RunRepositoryManager()
         {
-            Logger.Trace("SetupAndRestart");
-
-            var gitSetup = new GitSetup(Environment, CancellationToken);
-            var expectedPath = gitSetup.GitInstallationPath;
-            var setupDone = await gitSetup.SetupIfNeeded(progress.Percentage, progress.Remaining);
-            if (setupDone)
-                Environment.GitExecutablePath = gitSetup.GitExecutablePath;
-            else
-                Environment.GitExecutablePath = await LookForGitInstallationPath();
+            Logger.Trace("RunRepositoryManager");
 
-            Logger.Trace("Environment.GitExecutablePath \"{0}\" Exists:{1}", gitSetup.GitExecutablePath, gitSetup.GitExecutablePath.FileExists());
+            if (Environment.RepositoryPath != null)
+            {
+                new ActionTask(repositoryManager.Initialize())
+                    .Then(repositoryManager.Start)
+                    .Start();;
+            }
+        }
 
-            await RestartRepository().StartAwait();
+        private async Task LoadKeychain()
+        {
+            Logger.Trace("Loading Keychain");
 
-            if (Environment.IsWindows)
+            var firstConnection = Platform.Keychain.Connections.FirstOrDefault();
+            if (firstConnection == null)
             {
-                var credentialHelper = await GitClient.GetConfig("credential.helper", GitConfigSource.Global).StartAwait();
-
-                if (string.IsNullOrEmpty(credentialHelper))
-                {
-                    await GitClient.SetConfig("credential.helper", "wincred", GitConfigSource.Global).StartAwait();
-                }
+                Logger.Trace("No Host Found");
+            }
+            else
+            {
+                Logger.Trace("Loading Connection to Host:\"{0}\"", firstConnection);
+                await Platform.Keychain.Load(firstConnection).SafeAwait();
             }
         }
 
-        private async Task<NPath> LookForGitInstallationPath()
+        private static async Task<NPath> LookForGitInstallationPath(IGitClient gitClient, ISettings systemSettings)
         {
             NPath cachedGitInstallPath = null;
-            var path = SystemSettings.Get(Constants.GitInstallPathKey);
+            var path = systemSettings.Get(Constants.GitInstallPathKey);
             if (!String.IsNullOrEmpty(path))
                 cachedGitInstallPath = path.ToNPath();
 
@@ -143,7 +176,7 @@ private async Task<NPath> LookForGitInstallationPath()
             {
                 return cachedGitInstallPath;
             }
-            return await GitClient.FindGitInstallation().SafeAwait();
+            return await gitClient.FindGitInstallation();
         }
 
         protected void SetupMetrics(string unityVersion, bool firstRun)
@@ -172,6 +205,10 @@ protected void SetupMetrics(string unityVersion, bool firstRun)
             }
         }
 
+        protected abstract void SetupMetrics();
+        protected abstract void InitializeUI();
+        protected abstract void SetProjectToTextSerialization();
+
         private bool disposed = false;
         protected virtual void Dispose(bool disposing)
         {
@@ -189,27 +226,7 @@ public void Dispose()
             Dispose(true);
         }
 
-        public IEnvironment Environment
-        {
-            get
-            {
-                // if this is called while still null, it's because Unity wants
-                // to render something and we need to load icons, and that runs
-                // before EntryPoint. Do an early initialization
-                if (environment == null)
-                {
-                    environment = new DefaultEnvironment();
-                    var assetsPath = GetAssetsPath();
-                    var unityPath = GetUnityPath();
-                    var extensionInstallPath = DetermineInstallationPath();
-
-                    // figure out where we are
-                    environment.Initialize(extensionInstallPath.ToNPath(), unityPath.ToNPath(), assetsPath.ToNPath());
-                }
-                return environment;
-            }
-            protected set { environment = value; }
-        }
+        public abstract IEnvironment Environment { get; }
 
         public IPlatform Platform { get; protected set; }
         public virtual IProcessEnvironment GitEnvironment { get; set; }

src/GitHub.Api/Application/IApplicationManager.cs

@@ -17,6 +17,7 @@ interface IApplicationManager : IDisposable
         ITaskManager TaskManager { get; }
         IGitClient GitClient { get; }
         IUsageTracker UsageTracker { get; }
-        ITask RestartRepository();
+        void RestartRepository();
+        ITask InitializeRepository();
     }
 }

src/GitHub.Api/Cache/IBranchCache.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace GitHub.Unity
+{
+    interface IBranchCache
+    {
+        List<GitBranch> LocalBranches { get; set; }
+        List<GitBranch> RemoteBranches { get; set; }
+    }
+}

src/GitHub.Api/Git/GitBranch.cs

@@ -1,21 +1,35 @@
-using GitHub.Unity;
+using System;
 
 namespace GitHub.Unity
 {
-    struct GitBranch
+    interface ITreeData
     {
-        public string Name { get; private set; }
-        public string Tracking { get; private set; }
-        public bool Active { get; private set; }
+        string Name { get; }
+        bool IsActive { get; }
+    }
+
+    [Serializable]
+    struct GitBranch : ITreeData
+    {
+        private string name;
+        private string tracking;
+        private bool active;
+        public string Name { get { return name; } }
+        public string Tracking { get { return tracking; } }
+        public bool IsActive { get { return active; } }
 
         public GitBranch(string name, string tracking, bool active)
         {
             Guard.ArgumentNotNullOrWhiteSpace(name, "name");
-            Guard.ArgumentNotNull(tracking, "tracking");
 
-            Name = name;
-            Tracking = tracking;
-            Active = active;
+            this.name = name;
+            this.tracking = tracking;
+            this.active = active;
+        }
+
+        public override string ToString()
+        {
+            return $"{Name} Tracking? {Tracking} Active? {IsActive}";
         }
     }
 }

src/GitHub.Api/Git/GitRemote.cs

@@ -11,6 +11,7 @@ enum GitRemoteFunction
         Both
     }
 
+    [Serializable]
     struct GitRemote
     {
         public string Name;