refactor: use async methods to commit changes

Signed-off-by: leo <longshuang@msn.cn>

Author: love-linger

src/App.axaml.cs

@@ -158,13 +158,12 @@ public static void ShowWindow(object data)
             }
         }
 
-        public static async Task<bool> AskConfirmAsync(string message, Action onSure)
+        public static async Task<bool> AskConfirmAsync(string message)
         {
             if (Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime { MainWindow: { } owner })
             {
                 var confirm = new Views.Confirm();
                 confirm.Message.Text = message;
-                confirm.OnSure = onSure;
                 return await confirm.ShowDialog<bool>(owner);
             }
 

src/Models/Commit.cs

@@ -16,6 +16,14 @@ public enum CommitSearchMethod
         ByContent,
     }
 
+    public enum CommitCheckPassed
+    {
+        None = 0,
+        DetachedHead,
+        Filter,
+        FileCount,
+    }
+
     public class Commit
     {
         // As retrieved by: git mktree </dev/null

src/ViewModels/Checkout.cs

@@ -47,7 +47,7 @@ public override async Task<bool> Sure()
                 if (refs.Count == 0)
                 {
                     var msg = App.Text("Checkout.WarnLostCommits");
-                    var shouldContinue = await App.AskConfirmAsync(msg, null);
+                    var shouldContinue = await App.AskConfirmAsync(msg);
                     if (!shouldContinue)
                     {
                         _repo.SetWatcherEnabled(true);

src/ViewModels/CheckoutAndFastForward.cs

@@ -52,7 +52,7 @@ public override async Task<bool> Sure()
                 if (refs.Count == 0)
                 {
                     var msg = App.Text("Checkout.WarnLostCommits");
-                    var shouldContinue = await App.AskConfirmAsync(msg, null);
+                    var shouldContinue = await App.AskConfirmAsync(msg);
                     if (!shouldContinue)
                     {
                         _repo.SetWatcherEnabled(true);

src/ViewModels/CheckoutCommit.cs

@@ -47,7 +47,7 @@ public override async Task<bool> Sure()
                 if (refs.Count == 0)
                 {
                     var msg = App.Text("Checkout.WarnLostCommits");
-                    var shouldContinue = await App.AskConfirmAsync(msg, null);
+                    var shouldContinue = await App.AskConfirmAsync(msg);
                     if (!shouldContinue)
                     {
                         _repo.SetWatcherEnabled(true);

src/ViewModels/ConfirmEmptyCommit.cs

@@ -1,4 +1,4 @@
-using System;
+using System.Threading.Tasks;
 
 namespace SourceGit.ViewModels
 {
@@ -16,23 +16,25 @@ public string Message
             private set;
         }
 
-        public ConfirmEmptyCommit(bool hasLocalChanges, Action<bool> onSure)
+        public ConfirmEmptyCommit(WorkingCopy wc, bool autoPush, int unstagedCount)
         {
-            HasLocalChanges = hasLocalChanges;
-            Message = App.Text(hasLocalChanges ? "ConfirmEmptyCommit.WithLocalChanges" : "ConfirmEmptyCommit.NoLocalChanges");
-            _onSure = onSure;
+            _wc = wc;
+            _autoPush = autoPush;
+            HasLocalChanges = unstagedCount > 0;
+            Message = App.Text(HasLocalChanges ? "ConfirmEmptyCommit.WithLocalChanges" : "ConfirmEmptyCommit.NoLocalChanges");
         }
 
-        public void StageAllThenCommit()
+        public async Task StageAllThenCommitAsync()
         {
-            _onSure?.Invoke(true);
+            await _wc.CommitAsync(true, _autoPush, Models.CommitCheckPassed.FileCount);
         }
 
-        public void Continue()
+        public async Task ContinueAsync()
         {
-            _onSure?.Invoke(false);
+            await _wc.CommitAsync(false, _autoPush, Models.CommitCheckPassed.FileCount);
         }
 
-        private Action<bool> _onSure;
+        private readonly WorkingCopy _wc;
+        private readonly bool _autoPush;
     }
 }

src/ViewModels/CreateBranch.cs

@@ -131,7 +131,7 @@ public override async Task<bool> Sure()
                     if (refs.Count == 0)
                     {
                         var msg = App.Text("Checkout.WarnLostCommits");
-                        var shouldContinue = await App.AskConfirmAsync(msg, null);
+                        var shouldContinue = await App.AskConfirmAsync(msg);
                         if (!shouldContinue)
                         {
                             _repo.SetWatcherEnabled(true);

src/ViewModels/WorkingCopy.cs

@@ -606,19 +606,86 @@ public void ApplyCommitMessageTemplate(Models.CommitTemplate tmpl)
             CommitMessage = tmpl.Apply(_repo.CurrentBranch, _staged);
         }
 
-        public void Commit()
+        public async Task CommitAsync(bool autoStage, bool autoPush, Models.CommitCheckPassed checkPassed = Models.CommitCheckPassed.None)
         {
-            DoCommit(false, false);
-        }
+            if (string.IsNullOrWhiteSpace(_commitMessage))
+                return;
 
-        public void CommitWithAutoStage()
-        {
-            DoCommit(true, false);
-        }
+            if (!_repo.CanCreatePopup())
+            {
+                App.RaiseException(_repo.FullPath, "Repository has an unfinished job! Please wait!");
+                return;
+            }
 
-        public void CommitWithPush()
-        {
-            DoCommit(false, true);
+            if (autoStage && HasUnsolvedConflicts)
+            {
+                App.RaiseException(_repo.FullPath, "Repository has unsolved conflict(s). Auto-stage and commit is disabled!");
+                return;
+            }
+
+            if (_repo.CurrentBranch is { IsDetachedHead: true } && checkPassed < Models.CommitCheckPassed.DetachedHead)
+            {
+                var msg = App.Text("WorkingCopy.ConfirmCommitWithDetachedHead");
+                var sure = await App.AskConfirmAsync(msg);
+                if (sure)
+                    await CommitAsync(autoStage, autoPush, Models.CommitCheckPassed.DetachedHead);
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(_filter) && _staged.Count > _visibleStaged.Count && checkPassed < Models.CommitCheckPassed.Filter)
+            {
+                var msg = App.Text("WorkingCopy.ConfirmCommitWithFilter", _staged.Count, _visibleStaged.Count, _staged.Count - _visibleStaged.Count);
+                var sure = await App.AskConfirmAsync(msg);
+                if (sure)
+                    await CommitAsync(autoStage, autoPush, Models.CommitCheckPassed.Filter);
+                return;
+            }
+
+            if (checkPassed < Models.CommitCheckPassed.FileCount && !_useAmend)
+            {
+                if ((!autoStage && _staged.Count == 0) || (autoStage && _cached.Count == 0))
+                {
+                    await App.ShowDialog(new ConfirmEmptyCommit(this, autoPush, _cached.Count));
+                    return;
+                }
+            }
+
+            IsCommitting = true;
+            _repo.Settings.PushCommitMessage(_commitMessage);
+            _repo.SetWatcherEnabled(false);
+
+            var signOff = _repo.Settings.EnableSignOffForCommit;
+            var log = _repo.CreateLog("Commit");
+            var succ = true;
+            if (autoStage && _unstaged.Count > 0)
+                succ = await new Commands.Add(_repo.FullPath, _repo.IncludeUntracked).Use(log).ExecAsync().ConfigureAwait(false);
+
+            if (succ)
+                succ = await new Commands.Commit(_repo.FullPath, _commitMessage, signOff, _useAmend, _resetAuthor).Use(log).RunAsync().ConfigureAwait(false);
+
+            log.Complete();
+
+            if (succ)
+            {
+                CommitMessage = string.Empty;
+                UseAmend = false;
+                if (autoPush && _repo.Remotes.Count > 0)
+                {
+                    Models.Branch pushBranch = null;
+                    if (_repo.CurrentBranch == null)
+                    {
+                        var currentBranchName = await new Commands.QueryCurrentBranch(_repo.FullPath).GetResultAsync();
+                        pushBranch = new Models.Branch() { Name = currentBranchName };
+                    }
+
+                    if (_repo.CanCreatePopup())
+                        _repo.ShowAndStartPopup(new Push(_repo, pushBranch));
+                }
+            }
+
+            _repo.MarkBranchesDirtyManually();
+            _repo.SetWatcherEnabled(true);
+            IsCommitting = false;
         }
 
         private List<Models.Change> GetVisibleChanges(List<Models.Change> changes)
@@ -745,102 +812,6 @@ private void SetDetail(Models.Change change, bool isUnstaged)
                 DetailContext = new DiffContext(_repo.FullPath, new Models.DiffOption(change, isUnstaged), _detailContext as DiffContext);
         }
 
-        private void DoCommit(bool autoStage, bool autoPush, CommitCheckPassed checkPassed = CommitCheckPassed.None)
-        {
-            if (string.IsNullOrWhiteSpace(_commitMessage))
-                return;
-
-            if (!_repo.CanCreatePopup())
-            {
-                App.RaiseException(_repo.FullPath, "Repository has an unfinished job! Please wait!");
-                return;
-            }
-
-            if (autoStage && HasUnsolvedConflicts)
-            {
-                App.RaiseException(_repo.FullPath, "Repository has unsolved conflict(s). Auto-stage and commit is disabled!");
-                return;
-            }
-
-            if (_repo.CurrentBranch is { IsDetachedHead: true } && checkPassed < CommitCheckPassed.DetachedHead)
-            {
-                var msg = App.Text("WorkingCopy.ConfirmCommitWithDetachedHead");
-                _ = App.AskConfirmAsync(msg, () => DoCommit(autoStage, autoPush, CommitCheckPassed.DetachedHead));
-                return;
-            }
-
-            if (!string.IsNullOrEmpty(_filter) && _staged.Count > _visibleStaged.Count && checkPassed < CommitCheckPassed.Filter)
-            {
-                var msg = App.Text("WorkingCopy.ConfirmCommitWithFilter", _staged.Count, _visibleStaged.Count, _staged.Count - _visibleStaged.Count);
-                _ = App.AskConfirmAsync(msg, () => DoCommit(autoStage, autoPush, CommitCheckPassed.Filter));
-                return;
-            }
-
-            if (checkPassed < CommitCheckPassed.FileCount && !_useAmend)
-            {
-                if ((!autoStage && _staged.Count == 0) || (autoStage && _cached.Count == 0))
-                {
-                    _ = App.ShowDialog(new ConfirmEmptyCommit(_cached.Count > 0, stageAll => DoCommit(stageAll, autoPush, CommitCheckPassed.FileCount)));
-                    return;
-                }
-            }
-
-            IsCommitting = true;
-            _repo.Settings.PushCommitMessage(_commitMessage);
-            _repo.SetWatcherEnabled(false);
-
-            var signOff = _repo.Settings.EnableSignOffForCommit;
-            var log = _repo.CreateLog("Commit");
-            Task.Run(async () =>
-            {
-                var succ = true;
-                if (autoStage && _unstaged.Count > 0)
-                    succ = await new Commands.Add(_repo.FullPath, _repo.IncludeUntracked).Use(log).ExecAsync().ConfigureAwait(false);
-
-                if (succ)
-                    succ = await new Commands.Commit(_repo.FullPath, _commitMessage, signOff, _useAmend, _resetAuthor).Use(log).RunAsync().ConfigureAwait(false);
-
-                log.Complete();
-
-                Dispatcher.UIThread.Post(() =>
-                {
-                    if (succ)
-                    {
-                        CommitMessage = string.Empty;
-                        UseAmend = false;
-                        if (autoPush && _repo.Remotes.Count > 0)
-                            PushAfterCommit();
-                    }
-
-                    _repo.MarkBranchesDirtyManually();
-                    _repo.SetWatcherEnabled(true);
-                    IsCommitting = false;
-                });
-            });
-        }
-
-        private void PushAfterCommit()
-        {
-            if (_repo.CurrentBranch == null)
-            {
-                Task.Run(async () =>
-                {
-                    var currentBranchName = await new Commands.QueryCurrentBranch(_repo.FullPath).GetResultAsync();
-                    var tmp = new Models.Branch() { Name = currentBranchName };
-
-                    Dispatcher.UIThread.Post(() =>
-                    {
-                        if (_repo.CanCreatePopup())
-                            _repo.ShowAndStartPopup(new Push(_repo, tmp));
-                    });
-                });
-            }
-            else if (_repo.CanCreatePopup())
-            {
-                _repo.ShowAndStartPopup(new Push(_repo, null));
-            }
-        }
-
         private bool IsChanged(List<Models.Change> old, List<Models.Change> cur)
         {
             if (old.Count != cur.Count)
@@ -857,14 +828,6 @@ private bool IsChanged(List<Models.Change> old, List<Models.Change> cur)
             return false;
         }
 
-        private enum CommitCheckPassed
-        {
-            None = 0,
-            DetachedHead,
-            Filter,
-            FileCount,
-        }
-
         private Repository _repo = null;
         private bool _isLoadingData = false;
         private bool _isStaging = false;

src/Views/Confirm.axaml.cs

@@ -1,24 +1,16 @@
-using System;
 using Avalonia.Interactivity;
 
 namespace SourceGit.Views
 {
     public partial class Confirm : ChromelessWindow
     {
-        public Action OnSure
-        {
-            get;
-            set;
-        }
-
         public Confirm()
         {
             InitializeComponent();
         }
 
         private void Sure(object _1, RoutedEventArgs _2)
         {
-            OnSure?.Invoke();
             Close(true);
         }
 

src/Views/ConfirmEmptyCommit.axaml.cs

@@ -9,15 +9,19 @@ public ConfirmEmptyCommit()
             InitializeComponent();
         }
 
-        private void StageAllThenCommit(object _1, RoutedEventArgs _2)
+        private async void StageAllThenCommit(object _1, RoutedEventArgs _2)
         {
-            (DataContext as ViewModels.ConfirmEmptyCommit)?.StageAllThenCommit();
+            if (DataContext is ViewModels.ConfirmEmptyCommit vm)
+                await vm.StageAllThenCommitAsync();
+
             Close();
         }
 
-        private void Continue(object _1, RoutedEventArgs _2)
+        private async void Continue(object _1, RoutedEventArgs _2)
         {
-            (DataContext as ViewModels.ConfirmEmptyCommit)?.Continue();
+            if (DataContext is ViewModels.ConfirmEmptyCommit vm)
+                await vm.ContinueAsync();
+
             Close();
         }