Fix setting name, email and remote

Add support for setting name and email when there is no repository yet.

Author: shana

src/GitHub.Api/Git/Repository.cs

@@ -100,6 +100,8 @@ public ITask Revert(string changeset)
 
         public ITask ListLocks()
         {
+            if (repositoryManager == null)
+                return new ActionTask(TaskExtensions.CompletedTask);
             return repositoryManager.ListLocks(false);
         }
 
@@ -264,9 +266,16 @@ interface IUser
         string Name { get; set; }
         string Email { get; set; }
     }
+
+    [Serializable]
     class User : IUser
     {
         public string Name { get; set; }
         public string Email { get; set; }
+
+        public override string ToString()
+        {
+            return String.Format("Name: {0} Email: {1}", Name, Email);
+        }
     }
 }

src/GitHub.Api/NewTaskSystem/TaskExtensions.cs

@@ -6,6 +6,20 @@ namespace GitHub.Unity
 {
     static class TaskExtensions
     {
+        private static Task completedTask;
+
+        public static Task CompletedTask
+        {
+            get
+            {
+                if (completedTask == null)
+                {
+                    completedTask = TaskEx.FromResult(true);
+                }
+                return completedTask;
+            }
+        }
+
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "task")]
         public static void Forget(this Task task)
         {

src/UnityExtension/Assets/Editor/GitHub.Unity/UI/SettingsView.cs

@@ -83,11 +83,12 @@ class SettingsView : Subview
         [SerializeField] private int lockedFileSelection = -1;
         [SerializeField] private bool hasRemote;
         [SerializeField] private bool remoteHasChanged;
-        [SerializeField] private bool userDataHasChanged;
+        [NonSerialized] private bool userDataHasChanged;
 
         [SerializeField] private string newGitName;
         [SerializeField] private string newGitEmail;
         [SerializeField] private string newRepositoryRemoteUrl;
+        [SerializeField] private User cachedUser;
 
         public override void OnEnable()
         {
@@ -113,13 +114,16 @@ public override void OnRepositoryChanged(IRepository oldRepository)
 
             DetachHandlers(oldRepository);
             AttachHandlers(Repository);
+            activeRemote = Repository.CurrentRemote;
+            remoteHasChanged = true;
             Refresh();
         }
 
         public override void Refresh()
         {
             base.Refresh();
-            Repository.ListLocks().Start();
+            if (Repository != null)
+                Repository.ListLocks().Start();
         }
 
         private void AttachHandlers(IRepository repository)
@@ -144,12 +148,12 @@ public override void OnGUI()
         {
             scroll = GUILayout.BeginScrollView(scroll);
             {
-                if (Repository != null)
-                {
-                    OnUserSettingsGUI();
+                OnUserSettingsGUI();
 
-                    GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
+                GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
 
+                if (Repository != null)
+                {
                     OnRepositorySettingsGUI();
 
                     GUILayout.Space(EditorGUIUtility.standardVerticalSpacing);
@@ -173,34 +177,62 @@ private void MaybeUpdateData()
                 lockedFiles = new List<GitLock>();
 
             if (Repository == null)
+            {
+                if (cachedUser == null || String.IsNullOrEmpty(cachedUser.Name))
+                {
+                    var user = new User();
+                    GitClient.GetConfig("user.name", GitConfigSource.User)
+                        .Then((success, value) => user.Name = value).Then(
+                    GitClient.GetConfig("user.email", GitConfigSource.User)
+                        .Then((success, value) => user.Email = value))
+                    .FinallyInUI((success, ex) =>
+                    {
+                        if (success && !String.IsNullOrEmpty(user.Name))
+                        {
+                            cachedUser = user;
+                            userDataHasChanged = true;
+                            Redraw();
+                        }
+                    })
+                    .Start();
+                }
+
+                if (userDataHasChanged)
+                {
+                    newGitName = gitName = cachedUser.Name;
+                    newGitEmail = gitEmail = cachedUser.Email;
+                    userDataHasChanged = false;
+                }
                 return;
+            }
 
-            userDataHasChanged = !(Repository.User.Name == gitName && Repository.User.Email == gitEmail);
+            userDataHasChanged = Repository.User.Name != gitName || Repository.User.Email != gitEmail;
 
             if (!remoteHasChanged && !userDataHasChanged)
                 return;
 
+            if (userDataHasChanged)
+            {
+                userDataHasChanged = false;
+                newGitName = gitName = Repository.User.Name;
+                newGitEmail = gitEmail = Repository.User.Email;
+            }
+
             if (remoteHasChanged)
             {
                 remoteHasChanged = false;
                 hasRemote = activeRemote.HasValue && !String.IsNullOrEmpty(activeRemote.Value.Url);
                 if (!hasRemote)
                 {
                     repositoryRemoteName = DefaultRepositoryRemoteName;
-                    repositoryRemoteUrl = string.Empty;
+                    newRepositoryRemoteUrl = repositoryRemoteUrl = string.Empty;
                 }
                 else
                 {
                     repositoryRemoteName = activeRemote.Value.Name;
-                    repositoryRemoteUrl = activeRemote.Value.Url;
+                    newRepositoryRemoteUrl = repositoryRemoteUrl = activeRemote.Value.Url;
                 }
             }
-
-            if (userDataHasChanged)
-            {
-                gitName = Repository.User.Name;
-                gitEmail = Repository.User.Email;
-            }
         }
 
         private void ResetToDefaults()
@@ -243,42 +275,80 @@ private void OnUserSettingsGUI()
 
             EditorGUI.BeginDisabledGroup(isBusy);
             {
-                newGitName = EditorGUILayout.TextField(GitConfigNameLabel, gitName);
-                newGitEmail = EditorGUILayout.TextField(GitConfigEmailLabel, gitEmail);
+                newGitName = EditorGUILayout.TextField(GitConfigNameLabel, newGitName);
+                newGitEmail = EditorGUILayout.TextField(GitConfigEmailLabel, newGitEmail);
 
                 var needsSaving = newGitName != gitName || newGitEmail != gitEmail;
-                EditorGUI.BeginDisabledGroup(needsSaving);
+                EditorGUI.BeginDisabledGroup(!needsSaving);
                 {
                     if (GUILayout.Button(GitConfigUserSave, GUILayout.ExpandWidth(false)))
                     {
                         GitClient.SetConfig("user.name", newGitName, GitConfigSource.User)
-                            .Then((success, value) => { if (success) Repository.User.Name = value; })
+                            .Then((success, value) =>
+                            {
+                                if (success)
+                                {
+                                    if (Repository != null)
+                                    {
+                                        Repository.User.Name = value;
+                                    }
+                                    else
+                                    {
+                                        if (cachedUser == null)
+                                        {
+                                            cachedUser = new User();
+                                        }
+                                        cachedUser.Name = value;
+                                    }
+                                }
+                            })
                             .Then(
                         GitClient.SetConfig("user.email", newGitEmail, GitConfigSource.User)
-                            .Then((success, value) => { if (success) Repository.User.Email = value; }))
-                        .FinallyInUI((_, __) => isBusy = false)
+                            .Then((success, value) =>
+                            {
+                                if (success)
+                                {
+                                    if (Repository != null)
+                                    {
+                                        Repository.User.Email = value;
+                                    }
+                                    else
+                                    {
+                                        cachedUser.Email = value;
+                                        userDataHasChanged = true;
+                                    }
+                                }
+                            }))
+                        .FinallyInUI((_, __) =>
+                        {
+                            isBusy = false;
+                            Redraw();
+                        })
                         .Start();
                         isBusy = true;
                     }
                 }
+                EditorGUI.EndDisabledGroup();
             }
+            EditorGUI.EndDisabledGroup();
         }
 
         private void OnRepositorySettingsGUI()
         {
             GUILayout.Label(GitRepositoryTitle, EditorStyles.boldLabel);
+
             EditorGUI.BeginDisabledGroup(isBusy);
             {
                 newRepositoryRemoteUrl = EditorGUILayout.TextField(GitRepositoryRemoteLabel + ": " + repositoryRemoteName, newRepositoryRemoteUrl);
-                var needsSaving = newRepositoryRemoteUrl != repositoryRemoteUrl;
-                EditorGUI.BeginDisabledGroup(needsSaving);
+                var needsSaving = newRepositoryRemoteUrl != repositoryRemoteUrl && !String.IsNullOrEmpty(newRepositoryRemoteUrl);
+                EditorGUI.BeginDisabledGroup(!needsSaving);
                 {
                     if (GUILayout.Button(GitRepositorySave, GUILayout.ExpandWidth(false)))
                     {
                         try
                         {
                             isBusy = true;
-                            Repository.SetupRemote(repositoryRemoteName, repositoryRemoteUrl)
+                            Repository.SetupRemote(repositoryRemoteName, newRepositoryRemoteUrl)
                                 .FinallyInUI((_, __) =>
                                 {
                                     isBusy = false;
@@ -292,7 +362,9 @@ private void OnRepositorySettingsGUI()
                         }
                     }
                 }
+                EditorGUI.EndDisabledGroup();
             }
+            EditorGUI.EndDisabledGroup();
         }
 
         private bool ValidateGitInstall(string path)