refactor: worktree

- `Add Worktree` now only creates worktree based on HEAD
- Supports to checkout a remote branch as worktree
- Use different popups for `Add Worktree`, `Checkout <local_branch> as Worktree` and `Checkout <remote_branch> as Worktree`

Author: love-linger

src/Commands/Worktree.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -61,20 +62,33 @@ public Worktree(string repo)
             return worktrees;
         }
 
-        public async Task<bool> AddAsync(string fullpath, string name, bool createNew, string tracking)
+        public async Task<bool> AddAsync(string fullpath, string name)
+        {
+            if (string.IsNullOrEmpty(name))
+                Args = $"worktree add {fullpath.Quoted()}";
+            else
+                Args = $"worktree add -b {name} {fullpath.Quoted()}";
+
+            return await ExecAsync().ConfigureAwait(false);
+        }
+
+        public async Task<bool> AddWithLocalBranchAsync(string fullpath, string localBranch)
+        {
+            Args = $"worktree add -B {localBranch} {fullpath.Quoted()} {localBranch}";
+            return await ExecAsync().ConfigureAwait(false);
+        }
+
+        public async Task<bool> AddWithRemoteBranchAsync(string fullpath, string name, string remoteBranch, bool tracking)
         {
             var builder = new StringBuilder(1024);
             builder.Append("worktree add ");
-            if (!string.IsNullOrEmpty(tracking))
-                builder.Append("--track ");
-            if (!string.IsNullOrEmpty(name))
-                builder.Append(createNew ? "-b " : "-B ").Append(name).Append(' ');
-            builder.Append(fullpath.Quoted()).Append(' ');
-
-            if (!string.IsNullOrEmpty(tracking))
-                builder.Append(tracking);
-            else if (!string.IsNullOrEmpty(name) && !createNew)
-                builder.Append(name);
+
+            if (tracking)
+                builder.Append("--track -b ").Append(string.IsNullOrEmpty(name) ? Path.GetFileName(fullpath) : name).Append(' ');
+            else if (!string.IsNullOrEmpty(name))
+                builder.Append("-b ").Append(name).Append(' ');
+
+            builder.Append(fullpath.Quoted()).Append(' ').Append(remoteBranch);
 
             Args = builder.ToString();
             return await ExecAsync().ConfigureAwait(false);

src/Resources/Locales/en_US.axaml

@@ -12,11 +12,6 @@
   <x:String x:Key="Text.AddWorktree.Location.Placeholder" xml:space="preserve">Path for this worktree. Relative path is supported.</x:String>
   <x:String x:Key="Text.AddWorktree.Name" xml:space="preserve">Branch Name:</x:String>
   <x:String x:Key="Text.AddWorktree.Name.Placeholder" xml:space="preserve">Optional. Default is the destination folder name.</x:String>
-  <x:String x:Key="Text.AddWorktree.Tracking" xml:space="preserve">Track Branch:</x:String>
-  <x:String x:Key="Text.AddWorktree.Tracking.Toggle" xml:space="preserve">Tracking remote branch</x:String>
-  <x:String x:Key="Text.AddWorktree.WhatToCheckout" xml:space="preserve">What to Checkout:</x:String>
-  <x:String x:Key="Text.AddWorktree.WhatToCheckout.CreateNew" xml:space="preserve">Create New Branch</x:String>
-  <x:String x:Key="Text.AddWorktree.WhatToCheckout.Existing" xml:space="preserve">Existing Branch</x:String>
   <x:String x:Key="Text.AIAssistant" xml:space="preserve">AI Assistant</x:String>
   <x:String x:Key="Text.AIAssistant.Model" xml:space="preserve">MODEL</x:String>
   <x:String x:Key="Text.AIAssistant.Regen" xml:space="preserve">RE-GENERATE</x:String>
@@ -120,6 +115,14 @@
   <x:String x:Key="Text.Checkout.WarnUpdatingSubmodules" xml:space="preserve">The following submodules need to be updated:{0}Do you want to update them?</x:String>
   <x:String x:Key="Text.Checkout.WithFastForward" xml:space="preserve">Checkout &amp; Fast-Forward</x:String>
   <x:String x:Key="Text.Checkout.WithFastForward.Upstream" xml:space="preserve">Fast-Forward to:</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree" xml:space="preserve">Checkout Branch as Worktree</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.LocalBranch" xml:space="preserve">Local Branch:</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.NewBranchName" xml:space="preserve">New Branch Name:</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.NewBranchName.Placeholder" xml:space="preserve">Optional. Default is the destination folder name.</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.RemoteBranch" xml:space="preserve">Remote Branch:</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.Tracking" xml:space="preserve">Tracking this remote branch.</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.WorktreePath" xml:space="preserve">Worktree Path:</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.WorktreePath.Placeholder" xml:space="preserve">Path for this worktree. Relative path is supported.</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash" xml:space="preserve">Checkout Branch From Stash</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash.Branch" xml:space="preserve">New Branch:</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash.Stash" xml:space="preserve">Stash:</x:String>

src/Resources/Locales/zh_CN.axaml

@@ -124,6 +124,14 @@
   <x:String x:Key="Text.Checkout.WarnUpdatingSubmodules" xml:space="preserve">以下子模块需要更新：{0}是否立即更新？</x:String>
   <x:String x:Key="Text.Checkout.WithFastForward" xml:space="preserve">检出分支并快进</x:String>
   <x:String x:Key="Text.Checkout.WithFastForward.Upstream" xml:space="preserve">上游分支 ：</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree" xml:space="preserve">检出分支为新的工作树</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.LocalBranch" xml:space="preserve">本地分支 ：</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.NewBranchName" xml:space="preserve">新分支名称 ：</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.NewBranchName.Placeholder" xml:space="preserve">选填。默认使用目标文件夹名称。</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.RemoteBranch" xml:space="preserve">远程分支 ：</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.Tracking" xml:space="preserve">新分支跟踪此远程分支</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.WorktreePath" xml:space="preserve">工作树路径 ：</x:String>
+  <x:String x:Key="Text.CheckoutAsWorktree.WorktreePath.Placeholder" xml:space="preserve">必填。可填写相对路径。</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash" xml:space="preserve">从所选贮藏检出分支</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash.Branch" xml:space="preserve">新分支 ：</x:String>
   <x:String x:Key="Text.CheckoutBranchFromStash.Stash" xml:space="preserve">所选贮藏 ：</x:String>

src/ViewModels/AddWorktree.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
 using System.IO;
 using System.Threading.Tasks;
@@ -8,98 +7,35 @@ namespace SourceGit.ViewModels
 {
     public class AddWorktree : Popup
     {
-        [Required(ErrorMessage = "Worktree path is required!")]
         [CustomValidation(typeof(AddWorktree), nameof(ValidateWorktreePath))]
-        public string Path
+        public string WorktreePath
         {
-            get => _path;
-            set => SetProperty(ref _path, value, true);
+            get => _worktreePath;
+            set => SetProperty(ref _worktreePath, value, true);
         }
 
-        public bool CreateNewBranch
+        [CustomValidation(typeof(AddWorktree), nameof(ValidateBranchName))]
+        public string BranchName
         {
-            get => _createNewBranch;
-            set
-            {
-                if (SetProperty(ref _createNewBranch, value, true))
-                {
-                    if (value)
-                        SelectedBranch = null;
-                    else
-                        SelectedBranch = LocalBranches.Count > 0 ? LocalBranches[0] : null;
-                }
-            }
-        }
-
-        public List<Models.Branch> LocalBranches
-        {
-            get;
-            private set;
-        }
-
-        public Models.Branch SelectedBranch
-        {
-            get => _selectedBranch;
-            set => SetProperty(ref _selectedBranch, value);
-        }
-
-        public string NewBranchName
-        {
-            get => _newBranchName;
-            set => SetProperty(ref _newBranchName, value);
-        }
-
-        public bool SetTrackingBranch
-        {
-            get => _setTrackingBranch;
-            set
-            {
-                if (SetProperty(ref _setTrackingBranch, value))
-                    AutoSelectTrackingBranch();
-            }
-        }
-
-        public List<Models.Branch> RemoteBranches
-        {
-            get;
-            private set;
-        }
-
-        public Models.Branch SelectedTrackingBranch
-        {
-            get => _selectedTrackingBranch;
-            set => SetProperty(ref _selectedTrackingBranch, value);
+            get => _branchName;
+            set => SetProperty(ref _branchName, value, true);
         }
 
         public AddWorktree(Repository repo)
         {
             _repo = repo;
-
-            LocalBranches = new List<Models.Branch>();
-            RemoteBranches = new List<Models.Branch>();
-            foreach (var branch in repo.Branches)
-            {
-                if (branch.IsLocal)
-                {
-                    if (!branch.IsCurrent && !branch.HasWorktree)
-                        LocalBranches.Add(branch);
-                }
-                else
-                {
-                    RemoteBranches.Add(branch);
-                }
-            }
+            _worktreePath = Path.Combine(repo.GetRecommandedWorktreeDir(), "new-worktree");
         }
 
         public static ValidationResult ValidateWorktreePath(string path, ValidationContext ctx)
         {
             if (ctx.ObjectInstance is not AddWorktree creator)
-                return new ValidationResult("Missing runtime context to create branch!");
+                return new ValidationResult("Missing runtime context to add worktree!");
 
             if (string.IsNullOrEmpty(path))
                 return new ValidationResult("Worktree path is required!");
 
-            var fullPath = System.IO.Path.IsPathRooted(path) ? path : System.IO.Path.Combine(creator._repo.FullPath, path);
+            var fullPath = Path.IsPathRooted(path) ? path : Path.Combine(creator._repo.FullPath, path);
             var info = new DirectoryInfo(fullPath);
             if (info.Exists)
             {
@@ -115,70 +51,42 @@ public static ValidationResult ValidateWorktreePath(string path, ValidationConte
             return ValidationResult.Success;
         }
 
-        public override async Task<bool> Sure()
+        public static ValidationResult ValidateBranchName(string name, ValidationContext ctx)
         {
-            using var lockWatcher = _repo.LockWatcher();
-            ProgressDescription = "Adding worktree ...";
-
-            var branchName = GetBranchName(false);
-            var tracking = (_createNewBranch && _setTrackingBranch && _selectedTrackingBranch != null) ? _selectedTrackingBranch.FriendlyName : string.Empty;
-            var log = _repo.CreateLog("Add Worktree");
-
-            Use(log);
-
-            var succ = await new Commands.Worktree(_repo.FullPath)
-                .Use(log)
-                .AddAsync(_path, branchName, _createNewBranch, tracking);
-
-            log.Complete();
-            return succ;
-        }
+            if (ctx.ObjectInstance is not AddWorktree creator)
+                return new ValidationResult("Missing runtime context to add worktree!");
 
-        private void AutoSelectTrackingBranch()
-        {
-            if (!_setTrackingBranch || RemoteBranches.Count == 0)
-                return;
+            var test = !string.IsNullOrEmpty(name) ? name : Path.GetFileName(creator._worktreePath.TrimEnd('/').TrimEnd('\\'));
+            if (!Models.RefName.IsValidBranchName(test))
+                return new ValidationResult($"{test} is not a valid branch name!");
 
-            var name = GetBranchName(true);
-            if (!string.IsNullOrEmpty(name))
+            foreach (var b in creator._repo.Branches)
             {
-                var remoteBranch = RemoteBranches.Find(b => b.Name.Equals(name, StringComparison.Ordinal));
-                remoteBranch ??= RemoteBranches.Find(b => b.Name.EndsWith("/" + name, StringComparison.Ordinal));
-                if (remoteBranch != null)
-                {
-                    SelectedTrackingBranch = remoteBranch;
-                    return;
-                }
+                if (b.IsLocal && b.Name.Equals(test, StringComparison.Ordinal))
+                    return new ValidationResult($"A branch with name '{test}' already exists!");
             }
 
-            SelectedTrackingBranch = RemoteBranches[0];
+            return ValidationResult.Success;
         }
 
-        private string GetBranchName(bool fallback)
+        public override async Task<bool> Sure()
         {
-            do
-            {
-                if (!_createNewBranch)
-                {
-                    if (_selectedBranch != null)
-                        return _selectedBranch.Name;
+            using var lockWatcher = _repo.LockWatcher();
+            ProgressDescription = $"Adding a new worktree ...";
 
-                    break;
-                }
+            var log = _repo.CreateLog("Add Worktree");
+            Use(log);
 
-                if (!string.IsNullOrEmpty(_newBranchName))
-                    return _newBranchName;
-            } while (false);
+            var succ = await new Commands.Worktree(_repo.FullPath)
+                .Use(log)
+                .AddAsync(_worktreePath, _branchName);
 
-            return fallback ? System.IO.Path.GetFileName(_path.TrimEnd('/', '\\')) : string.Empty;
+            log.Complete();
+            return succ;
         }
 
-        private Repository _repo = null;
-        private string _path = string.Empty;
-        private bool _createNewBranch = true;
-        private Models.Branch _selectedBranch = null;
-        private string _newBranchName = string.Empty;
-        private bool _setTrackingBranch = false;
-        private Models.Branch _selectedTrackingBranch = null;
+        private readonly Repository _repo = null;
+        private string _worktreePath = string.Empty;
+        private string _branchName = string.Empty;
     }
 }

src/ViewModels/CheckoutAsWorktree.cs

@@ -0,0 +1,72 @@
+using System.ComponentModel.DataAnnotations;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SourceGit.ViewModels
+{
+    public class CheckoutAsWorktree : Popup
+    {
+        public Models.Branch Branch
+        {
+            get => _branch;
+        }
+
+        [CustomValidation(typeof(CheckoutAsWorktree), nameof(ValidateWorktreePath))]
+        public string WorktreePath
+        {
+            get => _worktreePath;
+            set => SetProperty(ref _worktreePath, value, true);
+        }
+
+        public CheckoutAsWorktree(Repository repo, Models.Branch branch)
+        {
+            _repo = repo;
+            _branch = branch;
+            _worktreePath = Path.Combine(repo.GetRecommandedWorktreeDir(), branch.Name.Replace('/', '-').Replace('\\', '-'));
+        }
+
+        public static ValidationResult ValidateWorktreePath(string path, ValidationContext ctx)
+        {
+            if (ctx.ObjectInstance is not CheckoutAsWorktree creator)
+                return new ValidationResult("Missing runtime context to checkout branch as worktree!");
+
+            if (string.IsNullOrEmpty(path))
+                return new ValidationResult("Worktree path is required!");
+
+            var fullPath = Path.IsPathRooted(path) ? path : Path.Combine(creator._repo.FullPath, path);
+            var info = new DirectoryInfo(fullPath);
+            if (info.Exists)
+            {
+                var files = info.GetFiles();
+                if (files.Length > 0)
+                    return new ValidationResult("Given path is not empty!!!");
+
+                var folders = info.GetDirectories();
+                if (folders.Length > 0)
+                    return new ValidationResult("Given path is not empty!!!");
+            }
+
+            return ValidationResult.Success;
+        }
+
+        public override async Task<bool> Sure()
+        {
+            using var lockWatcher = _repo.LockWatcher();
+            ProgressDescription = $"Checkout branch '{_branch.Name}' as worktree ...";
+
+            var log = _repo.CreateLog("Add Worktree");
+            Use(log);
+
+            var succ = await new Commands.Worktree(_repo.FullPath)
+                .Use(log)
+                .AddWithLocalBranchAsync(_worktreePath, _branch.Name);
+
+            log.Complete();
+            return succ;
+        }
+
+        private readonly Repository _repo;
+        private readonly Models.Branch _branch;
+        private string _worktreePath;
+    }
+}