squared 0.4.16 → 0.4.18

data/lib/squared/workspace/project/git.rb

@@ -4,7 +4,7 @@ module Squared
   module Workspace
     module Git
       GIT_REPO = Support.hashobj
-      GIT_PROTO = %r{^(?:https?|ssh|git|file)://}i.freeze
+      GIT_PROTO = %r{\A(https?|ssh|git|file)://}i.freeze
       private_constant :GIT_REPO, :GIT_PROTO
 
       attr_reader :revfile
@@ -74,7 +74,7 @@ module Squared
         @revdoc = JSON.parse(@revfile.read) if @revfile.exist?
       rescue StandardError => e
         @revfile = nil
-        warn log_message(Logger::WARN, e, pass: true) if @warning
+        warn log_message(Logger::WARN, e, pass: true)
         self
       else
         @revdoc = {} unless @revdoc.is_a?(Hash)
@@ -244,7 +244,17 @@ module Squared
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
-          status: %w[u|ignore-submodules=bm? ignored=b? untracked-files=b?],
+          status: %w[z u=bm? b|branch long s|short show-stash v|verbose column=b find-renames=i? ignore-submodules=b?
+                     ignored=b? porcelain=b? untracked-files=b?].freeze,
+          submodule: {
+            status: %w[cached recursive].freeze,
+            update: %w[checkout f|force init merge N|no-fetch no-recommend-shallow no-single-branch recommend-shallow
+                       rebase recursive remote single-branch depth=i filter=q jobs=i reference=b ref-format=q].freeze,
+            branch: %w[b|branch d|default].freeze,
+            sync: %w[recursive].freeze
+          }.freeze,
+          switch: %w[d|detach discard-changes f|force ignore-other-worktrees m|merge q|quiet conflict=b c|create=q
+                     C|force-create=q orphan=q t|track=b].freeze,
           tag: %w[n=im cleanup=b create-reflog i|ignore-case color=b? column=b contains=b? format=q merged=b?
                   no-contains=b? no-merged=b? points-at=q sort=q].freeze,
           no: {
@@ -270,6 +280,8 @@ module Squared
             rev_parse: %w[flags].freeze,
             revert: %w[edit gpg-sign rerere-autoupdate].freeze,
             show: %w[standard-notes].freeze,
+            status: %w[ahead-behind column renames].freeze,
+            switch: %w[guess progress recurse-submodules track].freeze,
             tag: %w[column].freeze
           }.freeze
         }.freeze
@@ -289,12 +301,10 @@ module Squared
           include Rake::DSL
 
           def populate(ws, **)
-            return if ws.series.exclude?(:pull, true)
-
-            namespace(name = ws.task_name('git')) do
-              all = ws.task_join(name, 'all')
+            return if ws.series.exclude?(:pull, true) || ws.size == 1
 
-              ws.format_desc(all, 'stash|rebase|autostash?,depend?')
+            namespace ws.task_name('git') do |ns|
+              ws.format_desc(all = ws.task_join(ns.scope.path, 'all'), 'stash|rebase|autostash?,depend?')
               task 'all' do |_, args|
                 args = args.to_a
                 cmd = if args.include?('stash')
@@ -311,6 +321,7 @@ module Squared
                 cmd << ws.task_sync('build')
                 Common::Utils.task_invoke(*cmd, **ws.invokeargs)
               end
+
               ws.series.sync << all
               ws.series.multiple << all
             end
@@ -332,25 +343,27 @@ module Squared
           'checkout' => %i[commit branch track detach path].freeze,
           'commit' => %i[add all amend amend-orig fixup].freeze,
           'diff' => %i[head branch files view between contain].freeze,
-          'fetch' => %i[origin remote].freeze,
+          'fetch' => %i[origin remote all].freeze,
           'files' => %i[cached modified deleted others].freeze,
-          'git' => %i[add blame clean mv revert rm].freeze,
+          'git' => %i[add blame clean mv revert rm status].freeze,
           'log' => %i[view between contain].freeze,
           'merge' => %i[commit no-commit send].freeze,
-          'pull' => %i[origin remote].freeze,
+          'pull' => %i[origin remote all].freeze,
           'rebase' => %i[branch onto send].freeze,
           'refs' => %i[heads tags remote].freeze,
-          'reset' => %i[commit index patch mode].freeze,
+          'reset' => %i[commit index patch mode undo].freeze,
           'restore' => %i[source staged worktree].freeze,
           'rev' => %i[commit build output].freeze,
           'show' => %i[format oneline textconv].freeze,
           'stash' => %i[push pop apply branch drop clear list].freeze,
-          'switch' => %i[create detach merge].freeze,
+          'submodule' => %i[status update branch url sync].freeze,
+          'switch' => %i[branch create detach].freeze,
           'tag' => %i[add sign delete list].freeze
         })
 
         def initialize(*, **)
           super
+          @submodule = basepath('.gitmodules').exist?
           initialize_ref Git.ref if gitpath.exist?
         end
 
@@ -360,7 +373,7 @@ module Squared
 
         def populate(*, **)
           super
-          return unless ref?(Git.ref)
+          return unless ref?(Git.ref) || @only
 
           namespace name do
             Git.subtasks do |action, flags|
@@ -382,11 +395,34 @@ module Squared
                         __send__(action, flag, args, remote: remote)
                       end
                     else
-                      format_desc action, flag, 'opts*'
+                      format_desc(action, flag, 'opts*', after: flag == :all && action == 'pull' ? 'pattern*' : nil)
                       task flag do |_, args|
                         __send__ action, flag, args.to_a
                       end
                     end
+                  when 'submodule'
+                    break unless @submodule
+
+                    case flag
+                    when :branch
+                      format_desc action, flag, 'path,opts*'
+                      task flag, [:path] do |_, args|
+                        path = param_guard(action, flag, args: args, key: :path)
+                        submodule(flag, args.extras, path: path)
+                      end
+                    when :url
+                      format_desc action, flag, 'path,url,opts*'
+                      task flag, [:path, :url] do |_, args|
+                        path = param_guard(action, flag, args: args, key: :path)
+                        url = param_guard(action, flag, args: args, key: :url)
+                        submodule(flag, args.extras, path: path, url: url)
+                      end
+                    else
+                      format_desc action, flag, 'opts*,path*'
+                      task flag do |_, args|
+                        submodule flag, args.to_a
+                      end
+                    end
                   when 'commit'
                     case flag
                     when :all
@@ -587,12 +623,12 @@ module Squared
                       format_desc action, flag, 'ref,opts*'
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
-                        if commit
-                          args = args.extras
-                        else
-                          commit, opts = choice_commit(values: ['Options'])
-                          args = OptionPartition.strip(opts)
-                        end
+                        args = if commit
+                                 args.extras
+                               else
+                                 commit, opts = choice_commit(values: ['Options'])
+                                 OptionPartition.strip(opts)
+                               end
                         checkout(flag, args, commit: commit)
                       end
                     when :detach
@@ -682,10 +718,10 @@ module Squared
                     when :create
                       format_desc action, flag, '(^)name,ref?=HEAD|:'
                       task flag, [:name, :commit] do |_, args|
-                        target = param_guard(action, flag, args: args, key: :name)
+                        branch = param_guard(action, flag, args: args, key: :name)
                         commit = commithead args.commit
                         commit, track = choice_commit(values: ['Track? [Y|n]'], force: false) if commit == ':'
-                        switch(flag, target: target, commit: commit, track: track)
+                        switch(flag, branch: branch, commit: commit, track: track)
                       end
                     when :detach
                       format_desc action, flag, 'ref?=HEAD'
@@ -693,11 +729,16 @@ module Squared
                         commit = commithead(args.commit) || choice_commit(force: false)
                         switch(flag, commit: commit)
                       end
-                    when :merge
-                      format_desc action, flag, 'branch?'
-                      task flag, [:branch] do |_, args|
-                        commit = args.branch || choice_refs('Choose a branch')
-                        switch(flag, commit: commit)
+                    when :branch
+                      format_desc action, flag, 'name|:,opts*'
+                      task flag, [:name] do |_, args|
+                        if (branch = args.name)
+                          args = args.extras
+                          branch = nil if branch == ':'
+                        else
+                          args = []
+                        end
+                        switch(flag, args, branch: branch || choice_refs('Choose a branch'))
                       end
                     end
                   when 'reset'
@@ -718,10 +759,10 @@ module Squared
                         end
                         print_success if success?(reset(flag, args, commit: commit))
                       end
-                    when :index
-                      format_desc action, flag, 'opts*,pathspec*'
+                    when :index, :undo
+                      format_desc(action, flag, flag == :index ? 'opts*,pathspec*' : nil)
                       task flag do |_, args|
-                        reset flag, args.to_a
+                        reset(flag, flag == :index ? args.to_a : [])
                       end
                     when :mode
                       format_desc action, flag, 'mode,ref?=HEAD|:'
@@ -763,28 +804,28 @@ module Squared
                     when :branch
                       format_desc action, flag, 'upstream,branch?=HEAD,opts*'
                       task flag, [:upstream] do |_, args|
-                        if (upstream = args.upstream)
-                          args = args.extras
-                        else
-                          upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
-                          args = OptionPartition.strip(opts)
-                        end
+                        args = if (upstream = args.upstream)
+                                 args.extras
+                               else
+                                 upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
+                                 OptionPartition.strip(opts)
+                               end
                         rebase(flag, args, upstream: upstream)
                       end
                     when :onto
                       format_desc action, flag, 'ref,upstream,branch?=HEAD'
                       task flag, [:commit, :upstream, :branch] do |_, args|
                         commit = commithead args.commit
-                        if commit
-                          upstream = param_guard(action, flag, args: args, key: :upstream)
-                          branch = args.branch
-                          args = []
-                        else
-                          commit = choice_refs 'Choose "onto" branch'
-                          target, opts = choice_commit(multiple: 2, values: ['Options'], reflog: false)
-                          branch, upstream = target
-                          args = OptionPartition.strip(opts)
-                        end
+                        args = if commit
+                                 upstream = param_guard(action, flag, args: args, key: :upstream)
+                                 branch = args.branch
+                                 []
+                               else
+                                 commit = choice_refs 'Choose "onto" branch'
+                                 target, opts = choice_commit(multiple: 2, values: ['Options'], reflog: false)
+                                 branch, upstream = target
+                                 OptionPartition.strip(opts)
+                               end
                         rebase(flag, args, commit: commit, upstream: upstream, branch: branch)
                       end
                     when :commit, :'no-commit'
@@ -820,7 +861,7 @@ module Squared
                         rev_parse(flag, ref: ref, size: size)
                       end
                     when :build
-                      format_desc action, flag, OPT_GIT[:status]
+                      format_desc action, flag, 'opts*'
                       task flag do |_, args|
                         revbuild flag, args.to_a
                       end
@@ -837,7 +878,7 @@ module Squared
                         ls_remote(flag, args.extras, remote: args.remote)
                       end
                     else
-                      format_desc action, flag, 'opts*,pattern*'
+                      format_desc(action, flag, 'opts*,pattern*', after: action == 'files' ? 'pathspec*' : nil)
                       task flag do |_, args|
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
@@ -848,13 +889,13 @@ module Squared
                       format_desc action, flag, 'ref,opts*,pathspec*'
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
-                        if commit
-                          args = args.extras
-                        else
-                          commit, opts, files = choice_commit(values: ['Options', ['Pathspec', true]])
-                          args = OptionPartition.strip(opts)
-                          files = files&.shellsplit
-                        end
+                        args = if commit
+                                 args.extras
+                               else
+                                 commit, opts, files = choice_commit(values: ['Options', ['Pathspec', true]])
+                                 files = files&.shellsplit
+                                 OptionPartition.strip(opts)
+                               end
                         restore(flag, args, commit: commit, files: files)
                       end
                     when :staged, :worktree
@@ -882,10 +923,13 @@ module Squared
                              when :mv then 'source+,destination'
                              when :revert then 'commit+' end
                     format_desc(action, flag, 'opts*', before: before, after: case flag
-                                                                              when :add then 'pathspec*,:pattern:*'
-                                                                              when :clean, :rm then 'pathspec*' end)
+                                                                              when :add
+                                                                                'pathspec*,pattern*'
+                                                                              when :clean, :rm, :status
+                                                                                'pathspec*'
+                                                                              end)
                     task flag do |_, args|
-                      git flag, args.to_a
+                      __send__(flag == :status ? :status : :git, flag, args.to_a)
                     end
                   end
                 end
@@ -909,13 +953,12 @@ module Squared
           super
         end
 
-        def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
+        def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil, hint: nil)
           cmd, opts = git_session('pull', opts: opts)
+          cmd << '--autostash' if option('autostash')
           if flag == :rebase
             cmd << '--rebase'
-            cmd << '--autostash' if option('autostash')
           else
-            cmd << '--autostash' if flag == :autostash
             if (val = option('rebase', ignore: false))
               cmd << case val
                      when '0', 'false'
@@ -924,15 +967,51 @@ module Squared
                        VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
                      end
             end
+            case flag
+            when :all
+              unless git_spawn('status -s -z --untracked-files=all').empty?
+                if confirm('Stash local changes? [Y/n] ', 'Y')
+                  git_spawn 'stash push --keep-index --quiet'
+                elsif !(force = confirm('Force checkout? [y/N] ', 'N'))
+                  return
+                end
+              end
+              op = OptionPartition.new(opts, OPT_GIT[:pull], cmd, project: self, no: OPT_GIT[:no][:pull])
+              reg = if op.empty?
+                      []
+                    else
+                      opts = op.uniq(opts)
+                      matchmap op
+                    end
+              session_done op.target
+              heads = []
+              cur = nil
+              foreachref('heads', format: '%(if)%(HEAD)%(then)* %(end)%(refname:short)').each do |line|
+                line.chomp!
+                cur ||= line.delete_prefix!('* ')
+                heads << line if matchany?(line, reg)
+              end
+              raise_error('head not found', hint: 'for-each-ref') unless cur
+              opts << 'ff-only' if opts.empty? && !option('ff-only', equals: '0')
+              (heads.dup << cur).each_with_index do |branch, index|
+                next unless (index < heads.size && cur != branch) || index == heads.size
+
+                git_spawn 'switch --quiet', force && '--force', shell_quote(branch)
+                pull(nil, opts, sync: false, hint: branch) if heads.include?(branch)
+              end
+              return
+            when :autostash
+              cmd << '--autostash'
+            end
           end
           append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag, from: :pull)
-          source(sync: sync, sub: if verbose
+          source(sync: sync, sub: if stdout?
                                     [
                                       { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: color(:red), index: 4 },
                                       { pat: /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, styles: color(:green), index: 3 }
                                     ]
-                                  end, **threadargs)
+                                  end, hint: hint, **threadargs)
         end
 
         def rebase(flag = nil, opts = [], sync: invoked_sync?('rebase', flag), commit: nil, upstream: nil, branch: nil,
@@ -956,6 +1035,10 @@ module Squared
             cmd << upstream
             append_head branch
           else
+            unless gitpath('REBASE_HEAD').exist?
+              puts log_message(Logger::INFO, name, 'no rebase in progress', hint: command) if stdout?
+              return
+            end
             return unless VAL_GIT[:rebase][:send].include?(command)
 
             cmd << "--#{command}"
@@ -969,6 +1052,7 @@ module Squared
 
         def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
           opts = git_session('fetch', opts: opts).last
+          opts << 'all' if flag == :all || option('all')
           append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]),
                                                            remote: remote, flag: flag, from: :fetch)
           source(sync: sync, **threadargs)
@@ -1008,15 +1092,15 @@ module Squared
             cmd, opts = git_session('stash', flag, opts: opts)
             list = OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])
             if flag == :list
-              list += collect_hash(OPT_GIT[:log])
-              no = collect_hash(OPT_GIT[:no][:log])
+              list += collect_hash OPT_GIT[:log]
+              no = collect_hash OPT_GIT[:no][:log]
             end
             op = OptionPartition.new(opts, list, cmd, project: self, no: no, first: flag == :push ? matchpathspec : nil)
             case flag
             when :push
               append_pathspec op.extras
             when :pop, :apply, :drop, :branch
-              if op.extras.delete(':')
+              if op.remove(':')
                 if flag == :branch
                   if op.empty?
                     values = [['Branch name', true]]
@@ -1051,30 +1135,35 @@ module Squared
             end
           else
             git_session('stash', 'push', opts: opts)
-            append_option(OPT_GIT[:stash][:push].grep_v(/[=|]/), no: true, ignore: false)
+            append_option(OptionPartition.select(OPT_GIT[:stash][:push], no: false), no: true, ignore: false)
             append_message
           end
           source(banner: !quiet?, sync: sync, **threadargs)
         end
 
-        def status(*)
-          cmd = git_session 'status'
-          cmd << (option('long') ? '--long' : '--short')
-          cmd << '--branch' if option('branch')
-          if (val = option('ignore-submodules', ignore: false))
-            cmd << basic_option('ignore-submodules', case val
-                                                     when '0', 'none'
-                                                       'none'
-                                                     when '1', 'untracked'
-                                                       'untracked'
-                                                     when '2', 'dirty'
-                                                       'dirty'
-                                                     else
-                                                       'all'
-                                                     end)
+        def status(flag = nil, opts = [])
+          cmd, opts = git_session('status', opts: opts)
+          if flag
+            op = OptionPartition.new(opts, OPT_GIT[:status], cmd, project: self, no: OPT_GIT[:no][:status])
+            append_pathspec op.extras
+          else
+            cmd << (option('long') ? '--long' : '--short')
+            cmd << '--branch' if option('branch')
+            if (val = option('ignore-submodules', ignore: false))
+              cmd << basic_option('ignore-submodules', case val
+                                                       when '0', 'none'
+                                                         'none'
+                                                       when '1', 'untracked'
+                                                         'untracked'
+                                                       when '2', 'dirty'
+                                                         'dirty'
+                                                       else
+                                                         'all'
+                                                       end)
+            end
+            append_pathspec
           end
-          append_pathspec
-          if verbose
+          if stdout?
             r = color(:red)
             g = color(:green)
             sub = if session_arg?('short')
@@ -1115,7 +1204,7 @@ module Squared
           kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.call : @revbuild || {}
           case flag
           when :build
-            op = OptionPartition.new(opts, OPT_GIT[:status], project: self)
+            op = OptionPartition.new(opts, %w[ignore-submodules=b? ignored=b? untracked-files=b?], project: self)
             op.clear(append: true)
             args = op.to_a
           else
@@ -1127,7 +1216,7 @@ module Squared
           if (cur = workspace.rev_entry(name)) && cur['revision'] == sha && !env('REVBUILD_FORCE')
             files = status_digest(*args, **kwargs)
             if cur['files'].size == files.size && cur['files'].find { |key, val| files[key] != val }.nil?
-              if verbose
+              if stdout?
                 if (since = workspace.rev_timesince(name, 'build'))
                   puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: "#{since} ago")
                 else
@@ -1172,6 +1261,9 @@ module Squared
           when :patch
             cmd << '--patch'
             append_pathspec(refs, pass: false)
+          when :undo
+            cmd << '--hard HEAD@{1}'
+            ref = false
           end
           unless ref == false
             append_commit(ref, head: true)
@@ -1182,7 +1274,7 @@ module Squared
 
         def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil, merge: false)
           cmd, opts = git_session('checkout', opts: opts)
-          append_option 'force', 'merge'
+          append_option 'force', 'f', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
@@ -1224,7 +1316,7 @@ module Squared
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
-            cmd << '--force' if option('force')
+            cmd << '--force' if option('force', 'f')
             if !commit && message && (sha = commithash(message))
               commit = sha
               message = nil
@@ -1255,7 +1347,7 @@ module Squared
                                                                            first: matchpathspec)
           case flag
           when :between, :contain
-            op << shell_quote(range.join(flag == :between ? '..' : '...'))
+            op.add_quote(range.join(flag == :between ? '..' : '...'))
           else
             op.merge(index)
           end
@@ -1278,19 +1370,18 @@ module Squared
             op << '--no-index'
             append_pathspec(refs, parent: true)
           else
+            op << '--merge-base' if option('merge-base')
             case flag
             when :view
-              op << '--merge-base' if option('merge-base')
               op.merge(range)
             when :between, :contain
               op.delete('--merge-base')
-              op << shell_quote(range.join(flag == :between ? '..' : '...'))
+              op.add_quote(range.join(flag == :between ? '..' : '...'))
             else
-              op << '--merge-base' if option('merge-base')
-              op << shell_quote(branch) if branch
+              op.add_quote(branch) if branch
               if !index.empty?
                 if op.arg?('cached')
-                  raise_error("one commit only: #{index.join(', ')}", hint: '--cached') if index.size > 1
+                  raise_error("one commit only: #{index.join(', ')}", hint: 'cached') if index.size > 1
                   op << index.first
                 else
                   op.merge(index)
@@ -1342,16 +1433,16 @@ module Squared
             branch, origin, hint = line.split('...')
             if hint && !hint.match?(/^\[(\D+0,\D+0)\]$/)
               raise_error('work tree is not usable', hint: hint[1..-2])
-            elsif origin.empty?
+            elsif !origin || origin.empty?
               return nil if pass
               break if dryrun
 
               unless (origin = option('upstream', prefix: 'git', ignore: false))
                 if (origin = choice_refs('Choose an upstream', 'remotes', attempts: 1, force: false))
                   git_spawn 'branch', quote_option('set-upstream-to', origin)
-                else
-                  origin = readline('Enter an upstream', force: true)
+                  break
                 end
+                origin = readline('Enter an upstream', force: true)
               end
               raise_error('missing remote name', hint: origin) unless origin.include?('/')
               upstream = true
@@ -1398,6 +1489,10 @@ module Squared
               append_commit(*op.extras)
             end
           else
+            unless gitpath('MERGE_HEAD').exist?
+              puts log_message(Logger::INFO, name, 'no merge in progress', hint: command) if stdout?
+              return
+            end
             return unless VAL_GIT[:merge][:send].include?(command)
 
             cmd << "--#{command}"
@@ -1420,7 +1515,7 @@ module Squared
                        '--track'
                      end
             end
-            cmd << '--force' if option('force')
+            cmd << '--force' if option('force', 'f')
             cmd << shell_quote(target)
             cmd << shell_quote(ref) if ref
           when :track
@@ -1435,14 +1530,12 @@ module Squared
             end
           when :delete
             remote&.each do |val|
-              source git_output('push', '--delete', *val.split('/', 2).map { |s| shell_quote(s) })
+              source git_output('push --delete', *val.split('/', 2).map { |s| shell_quote(s) })
             end
             force, list = refs.partition { |val| val.match?(/^[~^]/) }
             force.each do |val|
-              dr = val[0, 2]
-              d = dr.include?('^') ? '-D' : '-d'
-              r = '-r' if dr.include?('~')
-              source git_output('branch', d, r, shell_quote(val.sub(/^[~^]+/, '')))
+              r = '-r' if val.delete!('~')
+              source git_output('branch', val.delete!('^') ? '-D' : '-d', r, shell_quote(val))
             end
             return if list.empty?
 
@@ -1450,8 +1543,9 @@ module Squared
             append_value list
             remote = nil
           when :move, :copy
-            flag = "-#{flag.to_s[0]}"
-            cmd << (option('force') ? flag.upcase : flag)
+            s = "-#{flag.to_s[0]}"
+            s.upcase! if option('force', 'f')
+            cmd << s
             refs.compact.each { |val| cmd << shell_quote(val) }
             stdout = true
           when :current
@@ -1461,7 +1555,7 @@ module Squared
           when :list
             op = OptionPartition.new(opts, OPT_GIT[:branch], cmd << '--list',
                                      project: self, no: OPT_GIT[:no][:branch], single: /\Av+\z/)
-            op.each { |val| op << shell_quote(val) }
+            op.each { |val| op.add_quote(val) }
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
@@ -1471,12 +1565,12 @@ module Squared
             list_result(ret, 'branches', from: from)
             return
           else
-            head = git_spawn('rev-parse --abbrev-ref HEAD').chomp
-            if head.empty?
+            if (head = git_spawn('rev-parse --abbrev-ref HEAD').chomp).empty?
               ret = 0
             else
               git_spawn 'fetch --all --prune --quiet' if option('sync')
-              out, banner, from = source(cmd << '-vv --no-abbrev --list', io: true)
+              cmd << '-vv --no-abbrev --list'
+              out, banner, from = source(io: true)
               ret = write_lines(out, grep: [/^\*\s+#{Regexp.escape(head)}\s/], banner: banner, first: true) do |line|
                 next line if stdin?
 
@@ -1507,33 +1601,55 @@ module Squared
           if !ref
             print_success if flag == :create
           elsif remote && target
-            source git_output('push', '-u', shell_quote(ref.split('/', 2).first), shell_quote(target))
+            source git_output('push -u', shell_quote(ref.split('/', 2).first), shell_quote(target))
           end
         end
 
-        def switch(flag, opts = [], target: nil, commit: nil, track: nil)
-          cmd = git_session('switch', opts: opts).first
-          case flag
-          when :create
-            c = 'c'
-            if target.start_with?('^')
-              target = target[1..-1]
-              c = c.upcase
+        def switch(flag, opts = [], branch: nil, commit: nil, track: nil)
+          cmd, opts = git_session('switch', opts: opts)
+          cmd << '--force' if option('force', 'f')
+          if flag == :branch
+            op = OptionPartition.new(opts, OPT_GIT[:switch], cmd, project: self, no: OPT_GIT[:no][:switch])
+            op.add_quote(branch)
+          else
+            case flag
+            when :create
+              c = 'c'
+              if target.start_with?('^')
+                target = target[1..-1]
+                c = c.upcase
+              end
+              cmd << quote_option(c, target)
+              cmd << case (track ||= option('track', ignore: false))
+                     when 'n', 'N', '0', 'false'
+                       '--no-track'
+                     when 'y', 'Y', '1', 'true'
+                       '--track'
+                     when 'direct', 'inherit'
+                       basic_option 'track', track
+                     end
+            when :detach
+              cmd << "--#{flag}"
             end
-            cmd << quote_option(c, target)
-            cmd << case (track ||= option('track', ignore: false))
-                   when 'n', 'N', '0', 'false'
-                     '--no-track'
-                   when 'y', 'Y', '1', 'true'
-                     '--track'
-                   when 'direct', 'inherit'
-                     basic_option('track', track)
-                   end
-          when :detach, :merge
-            cmd << "--#{flag}"
+            append_head commit
+          end
+          source
+        end
+
+        def submodule(flag, opts = [], path: nil, url: nil)
+          cmd, opts = git_session('submodule', opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:submodule].fetch(flag, []), cmd, project: self)
+          case flag
+          when :branch, :url
+            op.adjoin("set-#{flag}")
+            op << '--'
+            op.add_path(path) if path
+            op.add_quote(url) if url
+          else
+            op.adjoin(flag)
+            op << '--recursive' if option('recursive', 'r')
+            op.splice(path: true)
           end
-          cmd << '--force' if option('force')
-          append_head commit
           source
         end
 
@@ -1556,19 +1672,15 @@ module Squared
             source(banner: false)
             return
           when :oneline
-            format = 'oneline'
+            format = flag.to_s
           end
-          if format
-            case (val = format.downcase)
-            when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
-              cmd << basic_option('format', val)
-            else
-              if format.match?(/^t?format:/) || format.include?('%')
-                cmd << quote_option('pretty', format)
-              else
-                opts << format
-              end
-            end
+          case format
+          when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
+            cmd << basic_option('format', format)
+          when /(?:^t?format:|%)/
+            cmd << quote_option('pretty', format)
+          else
+            opts << format if format
           end
           op = OptionPartition.new(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff], cmd,
                                    project: self,
@@ -1602,7 +1714,7 @@ module Squared
           cmd, opts = git_session('ls-remote', '--refs', opts: opts)
           cmd << "--#{flag}" unless flag == :remote
           op = OptionPartition.new(opts, OPT_GIT[:ls_remote], cmd, project: self)
-          op << shell_quote(remote) if remote
+          op.add_quote(remote) if remote
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: op.extras, prefix: "refs/#{flag}/")
@@ -1612,6 +1724,7 @@ module Squared
         def ls_files(flag, opts = [])
           cmd, opts = git_session('ls-files', "--#{flag}", opts: opts)
           op = OptionPartition.new(opts, OPT_GIT[:ls_files], cmd, project: self)
+          op.splice(path: true, pattern: true)
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: op.extras)
@@ -1640,15 +1753,16 @@ module Squared
             end
           when :add, :clean
             if flag == :add && !op.arg?('pathspec-from-file')
-              grep, list = op.partition { |val| val.start_with?(':') && val.end_with?(':') }
+              grep, list = op.partition { |val| OptionPartition.pattern?(val) }
               unless grep.empty? && !list.empty?
                 grep.map! { |val| Regexp.new(val[1..-2]) }
-                files = status_data.map! do |a, b|
-                  next if b.strip.empty? || (!grep.empty? && grep.none? { |pat| pat.match?(a) })
+                files = [].tap do |out|
+                  status_data.each do |a, b|
+                    next if b.strip.empty? || (!grep.empty? && grep.none? { |pat| pat.match?(a) })
 
-                  "#{sub_style(b, styles: color(:red))} #{a}"
+                    out << "#{sub_style(b, styles: color(:red))} #{a}"
+                  end
                 end
-                .compact
                 unless files.empty?
                   files = choice_index('Select files', files, multiple: true, force: true, trim: /^\S+\s/,
                                                               accept: [['Add?', false, true]])
@@ -1656,7 +1770,7 @@ module Squared
                 op.swap(list + files)
               end
             end
-            return source(git_session('status', '-s'), banner: false) unless append_pathspec(op.extras)
+            return source(git_session('status -s'), banner: false) unless append_pathspec(op.extras)
 
             verbose = flag == :add && !op.arg?('verbose')
             print_success if success?(source) && verbose
@@ -1686,7 +1800,7 @@ module Squared
         private
 
         def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
-                   multiple: false, from: nil, **kwargs)
+                   multiple: false, hint: nil, from: nil, send: :system, **kwargs)
           cmd = cmd.target if cmd.is_a?(OptionPartition)
           if io && banner == false
             from = nil
@@ -1704,7 +1818,8 @@ module Squared
           cmd = session_done cmd
           log&.info cmd
           banner = if banner
-                     format_banner((banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), ''), banner: true)
+                     banner = (banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), '')
+                     format_banner(hint ? "#{banner} (#{hint})" : banner, banner: true)
                    end
           on :first, from
           begin
@@ -1725,7 +1840,7 @@ module Squared
               end
             elsif !kwargs[:sub] && (sync || (!exception && !stderr))
               print_item banner unless multiple
-              ret = shell(cmd, exception: exception)
+              ret = shell(cmd, name: send, exception: exception)
             else
               require 'open3'
               if stderr
@@ -1752,16 +1867,7 @@ module Squared
         end
 
         def write_lines(data, grep: [], prefix: nil, sub: nil, banner: nil, loglevel: nil, pass: false, first: false)
-          grep = unless grep.empty?
-                   grep.map do |val|
-                     if val.is_a?(Regexp)
-                       val
-                     else
-                       val = ".*#{val}" if prefix && !val.sub!(/\A(\^|\\A)/, '')
-                       Regexp.new("#{prefix}#{val == '*' ? '.+' : val}")
-                     end
-                   end
-                 end
+          grep = grep.empty? ? nil : matchmap(grep, prefix)
           sub = nil if stdin?
           ret = 0
           out = []
@@ -1792,7 +1898,7 @@ module Squared
         def list_result(size, type, grep: [], action: 'found', from: nil)
           if size == 0
             puts empty_status("No #{type} were #{action}", 'grep', grep.join(', '))
-          elsif verbose
+          elsif stdout?
             styles = theme.fetch(:banner, []).reject { |s| s.to_s.end_with?('!') }
             styles << :bold if styles.size <= 1
             puts print_footer("#{size} #{size == 1 ? type.sub(/(?:(?<!l)e)?s\z/, '') : type}",
@@ -1835,8 +1941,7 @@ module Squared
           glob = kwargs.fetch(:include, [])
           pass = kwargs.fetch(:exclude, [])
           ret = {}
-          status_data(*args).each do |line|
-            file = line.first
+          status_data(*args).each do |file,|
             next if !glob.empty? && glob.none? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
             next if !pass.empty? && pass.any? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
 
@@ -1846,17 +1951,17 @@ module Squared
         end
 
         def status_data(*args)
-          ret = []
-          git_spawn('status -z -uall', *args).split("\x0").each do |line|
-            next unless line =~ /^(.)(.) (.+)$/
+          [].tap do |ret|
+            git_spawn('status -z -uall', *args).split("\x0").each do |line|
+              next unless line =~ /^(.)(.) (.+)$/
 
-            ret << [$3, $2, $1]
+              ret << [$3, $2, $1]
+            end
           end
-          ret
         end
 
         def append_pull(opts, list, target: @session, flag: nil, no: nil, remote: nil, from: nil)
-          target << '--force' if option('force', target: target)
+          target << '--force' if option('force', 'f', target: target)
           append_submodules(target: target, from: from)
           return if !remote && opts.empty?
 
@@ -1868,11 +1973,9 @@ module Squared
               when 'rebase'
                 op << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
               when 'shallow-since'
-                next unless (val = Date.parse($2))
-
-                op << quote_option($1, val.strftime('%F %T'))
+                op.append?($1) { Date.parse($2)&.strftime('%F %T') }
               when 'recurse-submodules'
-                op << basic_option($1, $2) unless op.arg?('recurse-submodules')
+                op.append?($1, $2, type: :basic)
               when 'refspec'
                 refspec << shell_escape($2, quote: true)
               end
@@ -1882,7 +1985,7 @@ module Squared
               op.errors << opt
             end
           end
-          op << '--verbose' if (flag || from == :fetch) && verbose && !op.arg?('quiet')
+          op << '--verbose' if (flag || from == :fetch) && stdout? && !op.arg?('quiet')
           if remote
             op.append(remote, delim: true)
             if (val = option('refspec', target: target, strict: true))
@@ -1895,7 +1998,7 @@ module Squared
             op.swap.merge(op.map! { |opt| shell_escape(opt, quote: true) })
             return
           elsif option('all')
-            cmd << '--all'
+            op << '--all'
           end
           op.clear(errors: true, subject: flag.to_s) if flag
         end
@@ -1974,20 +2077,28 @@ module Squared
         end
 
         def git_session(*cmd, opts: nil, worktree: true, **kwargs)
-          dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
+          dir = worktree ? [quote_option('work-tree', path), quote_option('git-dir', gitpath)] : []
           return session('git', *dir, *cmd, **kwargs) unless opts
 
           op = OptionPartition.new(opts, OPT_GIT[:common], dir, project: self)
-          ret = session('git', *op.to_a, *cmd, **kwargs)
-          [ret, op.extras]
+          [session('git', *op.to_a, *cmd, **kwargs), op.extras]
         end
 
         def git_output(*cmd, **kwargs)
           git_session(*cmd, main: false, options: false, **kwargs)
         end
 
-        def git_spawn(*cmd, stdout: true)
-          source(cmd.first.is_a?(Set) ? cmd.first : git_output(*cmd), io: true, banner: false, stdout: stdout)
+        def git_spawn(*cmd, exception: true, io: true, sync: true, stdout: true, banner: false, **kwargs)
+          kwargs[:send] = if sync
+                            :system
+                          else
+                            exception = false
+                            io = false
+                            stdout = false
+                            :spawn
+                          end
+          source(cmd.first.is_a?(Set) ? cmd.first : git_output(*cmd), exception: exception, io: io, sync: sync,
+                                                                      stdout: stdout, banner: banner, **kwargs)
         end
 
         def dryrun?(*, target: @session, **)
@@ -2002,8 +2113,8 @@ module Squared
           target.include?('--quiet') || (target.include?('-q') && stripext(target.first) == 'git')
         end
 
-        def gitpath
-          path + '.git'
+        def gitpath(*args)
+          path.join('.git', *args)
         end
 
         def repotrack(origin, branch, quote: true)