squared 0.4.36 → 0.5.0

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

@@ -3,8 +3,8 @@
 module Squared
   module Workspace
     module Git
-      GIT_REPO = Support.hashobj
-      GIT_PROTO = %r{\A(https?|ssh|git|file)://}i.freeze
+      GIT_REPO = {}
+      GIT_PROTO = %r{^(?:https?|ssh|git|file)://}i.freeze
       private_constant :GIT_REPO, :GIT_PROTO
 
       attr_reader :revfile
@@ -27,7 +27,7 @@ module Squared
           base = name
           @project.each_value { |proj| repo << proj if !proj.parent && check.call(proj) }
         else
-          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid') if warning
+          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid', pass: true) if warning
           return self
         end
         if base
@@ -58,8 +58,8 @@ module Squared
             end
           end
           key = task_name key
-          GIT_REPO[main][key] = [uri.to_s, opts]
-          @kind[key] << Project::Git
+          (GIT_REPO[main] ||= {})[key] = [uri.to_s, opts]
+          (@kind[key] ||= []) << Project::Git
         end
         if cache == true
           revbuild
@@ -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)
+        warn log_message(Logger::WARN, e, pass: true) if @warning
         self
       else
         @revdoc = {} unless @revdoc.is_a?(Hash)
@@ -91,13 +91,13 @@ module Squared
 
         data = @revdoc
         last = keys.pop
-        for key in keys
+        keys.each do |key|
           if data[key].is_a?(Hash)
             data = data[key]
           elsif create
             data = data[key] = {}
           else
-            return
+            return nil
           end
         end
         data[last] = val
@@ -134,7 +134,7 @@ module Squared
         File.write(@revfile, JSON.pretty_generate(@revdoc))
       rescue StandardError => e
         log&.debug e
-        warn log_message(Logger::WARN, e, pass: true) if warning
+        warn log_message(Logger::WARN, e, pass: true) if warning?
       ensure
         @revlock = false
       end
@@ -157,13 +157,14 @@ module Squared
       class Git < Base
         OPT_GIT = {
           common: %w[c=q bare glob-pathspecs icase-pathspecs literal-pathspecs no-optional-locks no-pager
-                     no-replace-objects noglob-pathspecs paginate config-env=q exec-path=p namespace=p].freeze,
+                     no-replace-objects noglob-pathspecs paginate attr-source=b config-env=q exec-path=p
+                     namespace=p].freeze,
           add: %w[A|all e|edit f|force ignore-errors ignore-missing ignore-removal i|interactive no-all
                   no-ignore-removal n|dry-run p|patch pathspec-file-nul renormalize sparse u|update v|verbose
                   chmod=b pathspec-from-file=p].freeze,
-          branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose abbrev=i color=b column=b
-                     contains=b format=q merged=b no-contains=b no-merged=b points-at=b u|set-upstream-to=b sort=q
-                     t|track=b].freeze,
+          branch: %w[a|all create-reflog i|ignore-case omit-empty q|quiet r|remotes v|verbose vv abbrev=i color=b
+                     column=b contains=b format=q merged=b no-contains=b no-merged=b points-at=b u|set-upstream-to=b
+                     sort=q t|track=b].freeze,
           checkout: %w[l d|detach f|force ignore-other-worktrees ignore-skip-worktree-bits m|merge p|patch
                        pathspec-file-nul q|quiet ours theirs conflict=b orphan=b pathspec-from-file=p t|track=b].freeze,
           diff: {
@@ -171,7 +172,8 @@ module Squared
             show: %w[s exit-code histogram].freeze
           }.freeze,
           fetch: {
-            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok recurse-submodules-default=b].freeze,
+            base: %w[multiple porcelain progress P|prune-tags refetch stdin u|update-head-ok
+                     recurse-submodules-default=b].freeze,
             pull: %w[4 6 n t a|append atomic dry-run f|force k|keep negotiate-only prefetch p|prune q|quiet
                      set-upstream unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q
                      recurse-submodules=v refmap=q o|server-option=q shallow-exclude=b shallow-since=v
@@ -179,9 +181,6 @@ module Squared
           }.freeze,
           git: {
             add: %w[N|intent-to-add refresh].freeze,
-            blame: %w[b c l s t w C=im? L=q M=im? S=p color-by-age color-lines first-parent incremental line-porcelain
-                      p|porcelain root score-debug f|show-name e|show-email n|show-number show-stats abbrev=i
-                      contents=p date=q encoding=b ignore-rev=b ignore-revs-file=p reverse=q].freeze,
             clean: %w[d x X f|force n|dry-run i|interactive q|quiet e|exclude=q].freeze,
             mv: %w[k f|force n|dry-run v|verbose].freeze,
             revert: %w[e S=bm? abort continue n|no-commit quit reference skip cleanup=b gpg-sign=b? m|mainline=i
@@ -199,9 +198,9 @@ module Squared
                      branches=q? committer=q decorate=b decorate-refs=q decorate-refs-exclude=q exclude=q
                      exclude-hidden=b glob=q grep=q grep-reflog=q n|max-count=i max-parents=i min-parents=i no-walk=b?
                      remotes=q? since=q since-as-filter=q skip=i tags=q? until=q].freeze,
-            format: %w[t children combined-all-paths oneline left-right no-diff-merges parents relative-date
-                       show-signature date=q diff-merges=b encoding=b expand-tabs=i format=q notes=b pretty=q?
-                       show-linear-break=q?].freeze,
+            format: %w[t children combined-all-paths dd oneline left-right no-diff-merges parents relative-date
+                       show-notes-by-default show-signature date=q diff-merges=b encoding=b expand-tabs=i format=q
+                       notes=b pretty=q? show-linear-break=q?].freeze,
             diff: %w[p R u z B=bm? C=bm? l=im G=qm I=qm M=bm? O=qm S=qm U=im binary check compact-summary cumulative
                      find-copies-harder full-index W|function-context w|ignore-all-space ignore-blank-lines
                      ignore-cr-at-eol ignore-space-at-eol b|ignore-space-change D|irreversible-delete graph
@@ -231,12 +230,13 @@ module Squared
                       theirs W|worktree conflict=b pathspec-from-file=p s|source=b].freeze,
           rev_parse: %w[absolute-git-dir all git-common-dir git-dir is-bare-repository is-inside-git-dir
                         is-inside-work-tree is-shallow-repository local-env-vars no-revs not q|quiet revs-only
-                        shared-index-path show-cdup show-prefix show-superproject-working-tree show-toplevel sq sq-quote
-                        symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q branches=q? default=q
-                        disambiguate=b exclude=q exclude-hidden=b git-path=p glob=q path-format=b? prefix=q remotes=q?
-                        resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].freeze,
-          show: %w[t combined-all-paths no-diff-merges remerge-diff show-signature diff-merges=b encoding=b
-                   expand-tabs=i notes=q show-notes=q?].freeze,
+                        shared-index-path show-cdup show-prefix show-ref-format show-superproject-working-tree
+                        show-toplevel sq sq-quote symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q
+                        branches=q? default=q disambiguate=b exclude=q exclude-hidden=b git-path=p glob=q
+                        output-object-format=b path-format=b? prefix=q remotes=q? resolve-git-dir=p short=i?
+                        show-object-format=b? since=q tags=q? until=q].freeze,
+          show: %w[t combined-all-paths no-diff-merges remerge-diff show-notes-by-default show-signature diff-merges=b
+                   encoding=b expand-tabs=i notes=q show-notes=q?].freeze,
           stash: {
             common: %w[q|quiet].freeze,
             push: %w[a|all u|include-untracked k|keep-index no-keep-index no-include-untracked pathspec-file-nul
@@ -244,21 +244,10 @@ module Squared
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
-          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,
+          status: %w[u|ignore-submodules=bm? ignored=b? untracked-files=b?],
+          tag: %w[n=im cleanup=b create-reflog i|ignore-case omit-empty color=b? column=b contains=b? format=q merged=b?
+                  no-contains=b? no-merged=b? points-at=q sort=q trailer=q].freeze,
           no: {
-            blame: %w[progress].freeze,
             branch: %w[color color-moved column track].freeze,
             checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
             fetch: {
@@ -280,8 +269,6 @@ 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
@@ -301,10 +288,12 @@ module Squared
           include Rake::DSL
 
           def populate(ws, **)
-            return if ws.series.exclude?(:pull, true) || ws.size == 1
+            return if ws.series.exclude?(:pull, true)
+
+            namespace(name = ws.task_name('git')) do
+              all = ws.task_join(name, 'all')
 
-            namespace ws.task_name('git') do |ns|
-              ws.format_desc(all = ws.task_join(ns.scope.path, 'all'), 'stash|rebase|autostash?,depend?')
+              ws.format_desc(all, 'stash|rebase|autostash?,depend?')
               task 'all' do |_, args|
                 args = args.to_a
                 cmd = if args.include?('stash')
@@ -321,7 +310,6 @@ module Squared
                 cmd << ws.task_sync('build')
                 Common::Utils.task_invoke(*cmd, **ws.invokeargs)
               end
-
               ws.series.sync << all
               ws.series.multiple << all
             end
@@ -343,27 +331,25 @@ 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 all].freeze,
+          'fetch' => %i[origin remote].freeze,
           'files' => %i[cached modified deleted others].freeze,
-          'git' => %i[add blame clean mv revert rm status].freeze,
+          'git' => %i[add clean mv revert rm].freeze,
           'log' => %i[view between contain].freeze,
           'merge' => %i[commit no-commit send].freeze,
-          'pull' => %i[origin remote all].freeze,
+          'pull' => %i[origin remote].freeze,
           'rebase' => %i[branch onto send].freeze,
           'refs' => %i[heads tags remote].freeze,
-          'reset' => %i[commit index patch mode undo].freeze,
+          'reset' => %i[commit index patch mode].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,
-          'submodule' => %i[status update branch url sync].freeze,
-          'switch' => %i[branch create detach].freeze,
+          'stash' => %i[push pop apply drop clear list].freeze,
+          'switch' => %i[create detach merge].freeze,
           'tag' => %i[add sign delete list].freeze
         })
 
         def initialize(*, **)
           super
-          @submodule = basepath('.gitmodules').exist?
           initialize_ref Git.ref if gitpath.exist?
         end
 
@@ -373,56 +359,33 @@ module Squared
 
         def populate(*, **)
           super
-          return unless ref?(Git.ref) || @only
+          return unless ref?(Git.ref)
 
           namespace name do
             Git.subtasks do |action, flags|
-              next if task_pass?(action)
+              next if @pass.include?(action)
 
               namespace action do
                 flags.each do |flag|
                   case action
                   when 'pull', 'fetch'
                     if flag == :remote
-                      format_desc action, flag, 'remote?,opts*'
+                      format_desc action, flag, 'remote,opts*'
                       task flag, [:remote] do |_, args|
                         if (remote = args.remote)
                           args = args.extras
                         else
                           remote = choice_remote
-                          args = args.to_a
+                          args = args.to_a.drop(1)
                         end
                         __send__(action, flag, args, remote: remote)
                       end
                     else
-                      format_desc(action, flag, 'opts*', after: flag == :all && action == 'pull' ? 'pattern*' : nil)
+                      format_desc action, flag, 'opts*'
                       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
@@ -436,12 +399,12 @@ module Squared
                         if flag == :fixup
                           ref, squash, pick = choice_commit(accept: [['Auto squash?', true]], reflog: false,
                                                             values: ['Pick [amend|reword]'])
-                          pick &&= case pick.downcase
-                                   when 'a', 'amend'
-                                     'amend'
-                                   when 'r', 'reword'
-                                     'reword'
-                                   end
+                          pick = case pick&.downcase
+                                 when 'a', 'amend'
+                                   'amend'
+                                 when 'r', 'reword'
+                                   'reword'
+                                 end
                           if squash
                             found = false
                             git_spawn(git_output('log --format=%h'), stdout: false).each do |val|
@@ -453,14 +416,12 @@ module Squared
                             end
                           end
                         end
-                        opts = []
-                        refs = []
-                        unless pick == 'reword'
-                          if flag == :add
-                            opts = param_guard(action, flag, args: args.to_a)
-                          elsif (refs = args.to_a).empty?
-                            refs = readline('Enter file patterns', force: true).shellsplit
-                          end
+                        refs = pick == 'reword' ? [] : param_guard(action, flag, args: args.to_a)
+                        if flag == :add
+                          opts = refs
+                          refs = []
+                        else
+                          opts = []
                         end
                         commit(flag, opts, refs: refs, ref: ref, squash: squash, pick: pick)
                       end
@@ -500,11 +461,9 @@ module Squared
                     end
                   when 'stash'
                     format_desc(action, flag, 'opts*', after: case flag
-                                                              when :push then 'pathspec*,:'
-                                                              when :branch then 'name,stash?|:'
+                                                              when :push then 'pathspec*'
                                                               when :clear, :list then nil
-                                                              else 'stash?|:'
-                                                              end)
+                                                              else 'stash?|:' end)
                     task flag do |_, args|
                       stash flag, args.to_a
                     end
@@ -542,7 +501,7 @@ module Squared
                           commit1 = commithead args.commit1
                           if commit1
                             commit2 = commithead param_guard(action, flag, args: args, key: :commit2)
-                            args = args.extras
+                            args = args.extras.to_a
                             range = [commit1, commit2]
                           else
                             range, opts, refs = choice_commit(multiple: view ? true : 2, values: %w[Options Pathspec])
@@ -604,7 +563,7 @@ module Squared
                             detach = args.detach
                             commit = commithead args.commit
                           end
-                          param_guard(action, flag, args: { create: create }, key: :create, pat: /\A[Bb]\z/) if create
+                          param_guard(action, flag, args: { create: create }, key: :create, pat: /\Ab\z/i) if create
                         else
                           branch = choice_refs 'Choose a branch to switch'
                         end
@@ -624,12 +583,12 @@ module Squared
                       format_desc action, flag, 'ref,opts*'
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
-                        args = if commit
-                                 args.extras
-                               else
-                                 commit, opts = choice_commit(values: ['Options'])
-                                 OptionPartition.strip(opts)
-                               end
+                        if commit
+                          args = args.extras
+                        else
+                          commit, opts = choice_commit(values: ['Options'])
+                          args = OptionPartition.strip(opts)
+                        end
                         checkout(flag, args, commit: commit)
                       end
                     when :detach
@@ -637,7 +596,7 @@ module Squared
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
                         unless commit
-                          commit, merge = choice_commit(values: ['Merge? [y/N]'])
+                          commit, merge = choice_commit(values: ['Merge? [y|N]'])
                           merge = merge&.upcase == 'Y'
                         end
                         checkout(flag, commit: commit, merge: merge)
@@ -674,7 +633,7 @@ module Squared
                         branch(flag, target: target, ref: ref, remote: remote)
                       end
                     when :delete
-                      format_desc action, flag, '[^~]name*,:?'
+                      format_desc action, flag, '(^~)name*,:?'
                       task flag do |_, args|
                         refs = args.to_a
                         if refs.empty? || (r = refs.last == ':')
@@ -719,10 +678,10 @@ module Squared
                     when :create
                       format_desc action, flag, '(^)name,ref?=HEAD|:'
                       task flag, [:name, :commit] do |_, args|
-                        branch = param_guard(action, flag, args: args, key: :name)
+                        target = 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, branch: branch, commit: commit, track: track)
+                        commit, track = choice_commit(values: ['Track? [Y|n]'], force: false) if commit == ':'
+                        switch(flag, target: target, commit: commit, track: track)
                       end
                     when :detach
                       format_desc action, flag, 'ref?=HEAD'
@@ -730,16 +689,11 @@ module Squared
                         commit = commithead(args.commit) || choice_commit(force: false)
                         switch(flag, commit: commit)
                       end
-                    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'))
+                    when :merge
+                      format_desc action, flag, 'branch?'
+                      task flag, [:branch] do |_, args|
+                        commit = args.branch || choice_refs('Choose a branch')
+                        switch(flag, commit: commit)
                       end
                     end
                   when 'reset'
@@ -752,19 +706,18 @@ module Squared
                           args = args.extras
                         else
                           commit, mode = choice_commit(values: ['Mode [mixed|soft|hard|N]'])
-                          args = args.extras.concat(case mode&.downcase
-                                                    when 'h', 'hard' then ['hard']
-                                                    when 's', 'soft' then ['soft']
-                                                    when 'n', 'N' then ['mixed', 'N']
-                                                    else ['mixed']
-                                                    end)
+                          args = args.extras.to_a.concat(case mode&.downcase
+                                                         when 'h', 'hard' then ['hard']
+                                                         when 's', 'soft' then ['soft']
+                                                         when 'n', 'N' then ['mixed', 'N']
+                                                         else ['mixed'] end)
                         end
                         print_success if success?(reset(flag, args, commit: commit))
                       end
-                    when :index, :undo
-                      format_desc(action, flag, flag == :index ? 'opts*,pathspec*' : nil)
+                    when :index
+                      format_desc action, flag, 'opts*,pathspec*'
                       task flag do |_, args|
-                        reset(flag, flag == :index ? args.to_a : [])
+                        reset flag, args.to_a
                       end
                     when :mode
                       format_desc action, flag, 'mode,ref?=HEAD|:'
@@ -806,28 +759,28 @@ module Squared
                     when :branch
                       format_desc action, flag, 'upstream,branch?=HEAD,opts*'
                       task flag, [:upstream] do |_, args|
-                        args = if (upstream = args.upstream)
-                                 args.extras
-                               else
-                                 upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
-                                 OptionPartition.strip(opts)
-                               end
+                        if (upstream = args.upstream)
+                          args = args.extras
+                        else
+                          upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
+                          args = 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
-                        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(reflog: false, multiple: 2, values: ['Options'])
-                                 branch, upstream = target
-                                 OptionPartition.strip(opts)
-                               end
+                        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
                         rebase(flag, args, commit: commit, upstream: upstream, branch: branch)
                       end
                     when :commit, :'no-commit'
@@ -863,9 +816,7 @@ module Squared
                         rev_parse(flag, ref: ref, size: size)
                       end
                     when :build
-                      next unless build?
-
-                      format_desc action, flag, 'opts*'
+                      format_desc action, flag, OPT_GIT[:status]
                       task flag do |_, args|
                         revbuild flag, args.to_a
                       end
@@ -882,7 +833,7 @@ module Squared
                         ls_remote(flag, args.extras, remote: args.remote)
                       end
                     else
-                      format_desc(action, flag, 'opts*,pattern*', after: action == 'files' ? 'pathspec*' : nil)
+                      format_desc action, flag, 'opts*,pattern*'
                       task flag do |_, args|
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
@@ -893,13 +844,13 @@ module Squared
                       format_desc action, flag, 'ref,opts*,pathspec*'
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
-                        args = if commit
-                                 args.extras
-                               else
-                                 commit, opts, files = choice_commit(values: ['Options', ['Pathspec', true]])
-                                 files = files&.shellsplit
-                                 OptionPartition.strip(opts)
-                               end
+                        if commit
+                          args = args.extras
+                        else
+                          commit, opts, files = choice_commit(values: ['Options', ['Pathspec', true]])
+                          args = OptionPartition.strip(opts)
+                          files = files&.shellsplit
+                        end
                         restore(flag, args, commit: commit, files: files)
                       end
                     when :staged, :worktree
@@ -908,14 +859,19 @@ module Squared
                         args = args.to_a
                         if args.empty? || args.last == ':'
                           files = []
-                          status_data.each { |row| files << row[0] if row[flag == :staged ? 2 : 1].match?(/[AMDRTC]/) }
+                          status_data.each do |line|
+                            case (flag == :staged ? line[2] : line[1])
+                            when /[AMDRTC]/
+                              files << line[0]
+                            end
+                          end
                           unless files.empty?
                             files = choice_index('Select a file', files, multiple: true, force: false,
                                                                          accept: 'Restore?')
                           end
                           args.pop
                           args, glob = args.partition { |val| val.match?(/^(?:[a-z-]+=|[^*]+$)/) }
-                          files.concat(glob)
+                          (files ||= []).concat(glob)
                           next if args.empty? && files.empty?
                         end
                         restore(flag, args, files: files)
@@ -923,18 +879,13 @@ module Squared
                     end
                   when 'git'
                     before = case flag
-                             when :blame then 'file'
                              when :mv then 'source+,destination'
-                             when :revert then 'commit+'
-                             end
+                             when :revert then 'commit+' end
                     format_desc(action, flag, 'opts*', before: before, after: case flag
-                                                                              when :add
-                                                                                'pathspec*,pattern*'
-                                                                              when :clean, :rm, :status
-                                                                                'pathspec*'
-                                                                              end)
+                                                                              when :add then 'pathspec*|:pattern:*'
+                                                                              when :clean, :rm then 'pathspec*' end)
                     task flag do |_, args|
-                      __send__(flag == :status ? :status : :git, flag, args.to_a)
+                      git flag, args.to_a
                     end
                   end
                 end
@@ -958,13 +909,14 @@ module Squared
           super
         end
 
-        def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil, hint: nil)
+        def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
           cmd, opts = git_session('pull', opts: opts)
-          cmd << '--autostash' if option('autostash')
           if flag == :rebase
             cmd << '--rebase'
+            cmd << '--autostash' if option('autostash')
           else
-            if (val = option('rebase', ignore: false))
+            cmd << '--autostash' if flag == :autostash
+            option('rebase', ignore: false) do |val|
               cmd << case val
                      when '0', 'false'
                        '--no-rebase'
@@ -972,52 +924,15 @@ 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
-                printsucc
-              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.sub!(/\A\* /, '')
-                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 stdout?
+          source(sync: sync, sub: if verbose
                                     [
                                       { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: color(:red), index: 4 },
-                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, styles: color(:green), index: 3 }
+                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: color(:green), index: 3 }
                                     ]
-                                  end, hint: hint, **threadargs)
+                                  end, **threadargs)
         end
 
         def rebase(flag = nil, opts = [], sync: invoked_sync?('rebase', flag), commit: nil, upstream: nil, branch: nil,
@@ -1030,7 +945,7 @@ module Squared
             return unless upstream
 
             op = OptionPartition.new(opts, OPT_GIT[:rebase], cmd, project: self, no: OPT_GIT[:no][:rebase])
-            op << upstream
+            cmd << shell_escape(upstream)
             append_head op.shift
             op.clear(pass: false)
           when :onto
@@ -1038,18 +953,14 @@ module Squared
 
             cmd << '--interactive' if option('interactive', 'i')
             cmd << shell_option('onto', commit) if commit
-            cmd << upstream
+            cmd << shell_escape(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}"
           end
-          source(sync: sync)
+          source
         end
 
         def autostash(*, sync: invoked_sync?('autostash'), **)
@@ -1058,7 +969,6 @@ 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)
@@ -1069,28 +979,31 @@ module Squared
 
           cmd = git_session('clone', worktree: false)
           opts = data[1].dup
-          if (val = option('depth', ignore: false))
+          option('depth', ignore: false) do |val|
             if (n = val.to_i) > 0
               opts[:depth] = n
             else
               opts.delete(:depth)
             end
           end
-          opts[:origin] = val if (val = option('origin', ignore: false))
-          if (val = option('branch', strict: true))
-            opts[:branch] = val
+          option('origin', ignore: false) { |val| opts[:origin] = val }
+          if (branch = option('branch', strict: true))
+            opts[:branch] = branch
             opts.delete(:revision)
-          elsif (val = option('revision', strict: true))
-            opts[:revision] = val
-            opts.delete(:branch)
-            opts.delete(:mirror)
+          else
+            option('revision', strict: true) do |val|
+              opts[:revision] = val
+              opts.delete(:branch)
+              opts.delete(:mirror)
+            end
           end
-          opts[:local] = val != '0' if (val = option('local', strict: true))
+          option('local', strict: true) { |val| opts[:local] = val != '0' }
+          option('bare') { |val| opts[:bare] = val }
           opts.delete(:'recurse-submodules') || opts.delete(:'no-recurse-submodules') if append_submodules(from: :clone)
           append_hash opts
           cmd << '--quiet' unless verbose
           append_value(data[0], path, delim: true)
-          source(sync: sync, banner: sync && !quiet?, multiple: !sync || quiet?)
+          source(banner: sync && !quiet?, multiple: !sync || quiet?)
         end
 
         def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
@@ -1098,34 +1011,19 @@ 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
-              op.append?('message', readline('Enter message', force: true), force: true) if op.remove(':')
               append_pathspec op.extras
-            when :pop, :apply, :drop, :branch
-              if op.remove(':')
-                if flag == :branch
-                  if op.empty?
-                    values = [['Branch name', true]]
-                  else
-                    op << op.shift
-                  end
-                end
-                out = choice_index('Choose a stash', git_spawn('stash list', stdout: false),
-                                   values: values, column: /^[^@]+@\{(\d+)\}/)
-                if values
-                  op.merge(out.reverse)
-                else
-                  op << out
-                end
+            when :pop, :apply, :drop
+              if op.extras.delete(':')
+                op << choice_index('Choose a stash', git_spawn('stash list', stdout: false),
+                                   column: /^[^@]+@\{(\d+)\}/, force: true)
               elsif !op.empty?
-                op << op.shift
-              elsif flag == :branch
-                raise_error 'no branch name'
+                op << shell_escape(op.pop)
               end
               op.clear
             when :clear
@@ -1142,35 +1040,30 @@ module Squared
             end
           else
             git_session('stash', 'push', opts: opts)
-            append_option(OptionPartition.select(OPT_GIT[:stash][:push], no: false), no: true, ignore: false)
+            append_option(OPT_GIT[:stash][:push].grep_v(/[=|]/), no: true, ignore: false)
             append_message
           end
           source(banner: !quiet?, sync: sync, **threadargs)
         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
+        def status(*)
+          cmd = git_session 'status'
+          cmd << (option('long') ? '--long' : '--short')
+          cmd << '--branch' if option('branch')
+          option('ignore-submodules', ignore: false) do |val|
+            cmd << basic_option('ignore-submodules', case val
+                                                     when '0', 'none'
+                                                       'none'
+                                                     when '1', 'untracked'
+                                                       'untracked'
+                                                     when '2', 'dirty'
+                                                       'dirty'
+                                                     else
+                                                       'all'
+                                                     end)
           end
-          if stdout?
+          append_pathspec
+          if verbose
             r = color(:red)
             g = color(:green)
             sub = if session_arg?('short')
@@ -1178,10 +1071,10 @@ module Squared
                       { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
                       { pat: /^([A-Z?!])(.+)$/, styles: g },
                       { pat: /^(\?\?)(.+)$/, styles: r },
-                      { pat: /^(## )(.+?)(\.{3})(.+)$/, styles: [nil, g, nil, r], index: -1 }
+                      { pat: /^(## )((?~\.{3}))(\.{3})(.+)$/, styles: [nil, g, nil, r], index: -1 }
                     ]
                   else
-                    [{ pat: /^(\t+)([a-z]+: +.+)$/, styles: r, index: 2 }]
+                    [pat: /^(\t+)([a-z]+: +.+)$/, styles: r, index: 2]
                   end
           end
           out, banner, from = source(io: true)
@@ -1192,8 +1085,8 @@ module Squared
         def revbuild(flag = nil, opts = [], sync: nil, **kwargs)
           statusargs = lambda do
             {
-              include: relativepath(Array(kwargs[:include]), all: true),
-              exclude: relativepath(Array(kwargs[:exclude]), all: true)
+              include: relativepath(as_a(kwargs[:include]), all: true),
+              exclude: relativepath(as_a(kwargs[:exclude]), all: true)
             }
           end
           unless workspace.closed
@@ -1211,19 +1104,19 @@ module Squared
           kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.call : @revbuild || {}
           case flag
           when :build
-            op = OptionPartition.new(opts, %w[ignore-submodules=b? ignored=b? untracked-files=b?], project: self)
+            op = OptionPartition.new(opts, OPT_GIT[:status], project: self)
             op.clear(append: true)
             args = op.to_a
           else
             args = []
-            args << basic_option('untracked-files', flag) if (flag = option('untracked-files', prefix: 'git'))
-            args << basic_option('ignore-submodules', flag) if (flag = option('ignore-submodules', prefix: 'git'))
-            args << basic_option('ignored', flag) if (flag = option('ignored', prefix: 'git'))
+            option('untracked-files', prefix: 'git') { |val| args << basic_option('untracked-files', val) }
+            option('ignore-submodules', prefix: 'git') { |val| args << basic_option('ignore-submodules', val) }
+            option('ignored', prefix: 'git') { |val| args << basic_option('ignored', val) }
           end
           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 stdout?
+              if verbose
                 if (since = workspace.rev_timesince(name, 'build'))
                   puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: "#{since} ago")
                 else
@@ -1234,11 +1127,14 @@ module Squared
             end
           end
           start = epochtime
-          build(*@output, sync: sync, from: :'git:revbuild')
+          build(@output, sync: sync, from: :'git:revbuild')
         rescue StandardError => e
-          print_error(e, pass: true)
+          warn log_message(Logger::WARN, e, pass: true) if warning?
         else
-          print_status(name, subject: 'revbuild', start: start, from: :completed)
+          if verbose
+            msg = sub_style('completed', styles: theme[:active])
+            puts log_message(Logger::INFO, name, msg, subject: 'revbuild', hint: time_format(epochtime - start))
+          end
           workspace.rev_write(name, { 'revision' => sha, 'files' => status_digest(*args, **kwargs) },
                               sync: sync, utc: 'build')
         end
@@ -1267,9 +1163,7 @@ module Squared
             end
           when :patch
             cmd << '--patch'
-          when :undo
-            cmd << '--hard HEAD@{1}'
-            ref = false
+            append_pathspec(refs, pass: false)
           end
           unless ref == false
             append_commit(ref, head: true)
@@ -1280,7 +1174,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', 'f', 'merge'
+          append_option 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
@@ -1301,14 +1195,13 @@ module Squared
           else
             op = OptionPartition.new(opts, OPT_GIT[:checkout], cmd, project: self, no: OPT_GIT[:no][:checkout],
                                                                     first: flag == :path ? matchpathspec : nil)
-            if flag == :path
+            if flag == :commit
+              op.append(commit)
+                .clear(pass: false)
+            else
               append_head
               append_pathspec(op.extras, pass: false)
-              print_success if success?(source)
-              return
             end
-            op.append(commit)
-              .clear(pass: false)
           end
           source
         end
@@ -1322,7 +1215,7 @@ module Squared
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
-            cmd << '--force' if option('force', 'f')
+            cmd << '--force' if option('force')
             if !commit && message && (sha = commithash(message))
               commit = sha
               message = nil
@@ -1341,19 +1234,19 @@ module Squared
             list_result(ret, 'tags', from: from, grep: op.extras)
             return
           end
-          remote ||= option('remote')
+          remote ||= option 'remote'
           source
           git_spawn('push', flag == :delete ? '-d' : nil, remote, *refs.map { |val| shell_quote(val) }) if remote
         end
 
         def log!(flag, opts = [], range: [], index: [])
           cmd, opts = git_session('log', opts: opts)
-          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd, project: self,
-                                                                           no: collect_hash(OPT_GIT[:no][:log]),
-                                                                           first: matchpathspec)
+          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd,
+                                   project: self, no: collect_hash(OPT_GIT[:no][:log]),
+                                   first: matchpathspec)
           case flag
           when :between, :contain
-            op.add_quote(range.join(flag == :between ? '..' : '...'))
+            op << shell_quote(range.join(flag == :between ? '..' : '...'))
           else
             op.merge(index)
           end
@@ -1376,18 +1269,19 @@ 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.add_quote(range.join(flag == :between ? '..' : '...'))
+              op << shell_quote(range.join(flag == :between ? '..' : '...'))
             else
-              op.add_quote(branch) if branch
+              op << '--merge-base' if option('merge-base')
+              op << shell_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)
@@ -1439,17 +1333,18 @@ 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 || origin.empty?
+            elsif 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)
-                  break
+                else
+                  origin = readline('Enter an upstream', force: true)
                 end
-                origin = readline('Enter an upstream', force: true)
               end
+              raise_error('missing remote name', hint: origin) unless origin.include?('/')
               upstream = true
             end
             break
@@ -1462,7 +1357,7 @@ module Squared
           co = git_session('commit', options: false)
           pu = git_output 'push', upstream && '--set-upstream'
           if dryrun
-            op.adjoin('--dry-run')
+            op.delete('--dry-run')
             co << '--dry-run'
             pu << '--dry-run'
           end
@@ -1474,6 +1369,7 @@ module Squared
           end
           pu << '--force-with-lease' if amend
           pu.merge(repotrack(origin, branch))
+          puts if pass
           source op
           source co
           source pu
@@ -1481,29 +1377,23 @@ module Squared
 
         def merge(flag, opts = [], command: nil, branch: nil)
           cmd, opts = git_session('merge', opts: opts)
-          display = false
           case flag
           when :commit, :'no-commit'
             op = OptionPartition.new(opts, OPT_GIT[:merge], cmd, project: self, no: OPT_GIT[:no][:merge])
+            raise_error 'no branch/commit' if op.empty?
             op << "--#{flag}" << '--'
             if branch
               op << branch
               op.clear(pass: false)
             else
-              raise_error 'no branch/commit' if op.empty?
               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}"
-            display = command == 'abort'
           end
-          print_success if success?(source, display)
+          source
         end
 
         def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil, remote: nil)
@@ -1511,17 +1401,17 @@ module Squared
           stdout = false
           case flag
           when :create
-            if (arg = option('track', ignore: false))
-              cmd << case arg
+            option('track', ignore: false) do |val|
+              cmd << case val
                      when '0', 'false'
                        '--no-track'
                      when 'direct', 'inherit'
-                       basic_option('track', arg)
+                       basic_option 'track', val
                      else
                        '--track'
                      end
             end
-            cmd << '--force' if option('force', 'f')
+            cmd << '--force' if option('force')
             cmd << shell_quote(target)
             cmd << shell_quote(ref) if ref
           when :track
@@ -1536,12 +1426,14 @@ 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, list = refs.partition { |val| val.start_with?(/[~^]/) }
             force.each do |val|
-              r = '-r' if val.delete!('~')
-              source git_output('branch', val.delete!('^') ? '-D' : '-d', r, shell_quote(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(/^[~^]+/, '')))
             end
             return if list.empty?
 
@@ -1549,9 +1441,8 @@ module Squared
             append_value list
             remote = nil
           when :move, :copy
-            s = +"-#{flag.to_s[0]}"
-            s.upcase! if option('force', 'f')
-            cmd << s
+            flag = "-#{flag.to_s[0]}"
+            cmd << (option('force') ? flag.upcase : flag)
             refs.compact.each { |val| cmd << shell_quote(val) }
             stdout = true
           when :current
@@ -1561,7 +1452,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.add_quote(val) }
+            op.each { |val| op << shell_quote(val) }
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
@@ -1571,19 +1462,19 @@ module Squared
             list_result(ret, 'branches', from: from)
             return
           else
-            if (head = git_spawn('rev-parse --abbrev-ref HEAD').chomp).empty?
+            head = git_spawn('rev-parse --abbrev-ref HEAD').chomp
+            if head.empty?
               ret = 0
             else
               git_spawn 'fetch --all --prune --quiet' if option('sync')
-              cmd << '-vv --no-abbrev --list'
-              out, banner, from = source(io: true)
+              out, banner, from = source(cmd << '-vv --no-abbrev --list', io: true)
               ret = write_lines(out, grep: [/^\*\s+#{Regexp.escape(head)}\s/], banner: banner, first: true) do |line|
                 next line if stdin?
 
                 data = line.sub(/^\*\s+/, '').split(/\s+/)
                 a = sub_style(data[0], styles: theme[:inline])
                 b = sub_style(data[1], styles: theme[:extra])
-                r = /\A(?:\[(.+?)(?=\]\s)\]\s)?(.+)\z/m.match(data[2..-1].join(' '))
+                r = /\A(?:\[((?~\]\s))\]\s)?(.+)\z/m.match(data[2..-1].join(' '))
                 if (r1 = r[1]) && r1 =~ /^(.+):(?: ([a-z]+) (\d+),)? ([a-z]+) (\d+)$/
                   write = ->(s1, s2) { "#{s1.capitalize.rjust(7)}: #{sub_style(s2, styles: theme[:warn])}" }
                   r1 = $1
@@ -1597,7 +1488,9 @@ module Squared
               end
               on :last, from
             end
-            print_error(name, 'no ref found', subject: 'branch', hint: 'head', pass: true) if ret == 0
+            if ret == 0
+              warn log_message(Logger::WARN, name, 'no ref found', subject: 'branch', hint: 'head', pass: true)
+            end
             return
           end
           return unless success?(source(stdout: stdout))
@@ -1605,55 +1498,33 @@ 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 = [], 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
-            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)
+        def switch(flag, opts = [], target: nil, commit: nil, track: nil)
+          cmd = git_session('switch', opts: opts).first
           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)
+          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, :merge
+            cmd << "--#{flag}"
           end
+          cmd << '--force' if option('force')
+          append_head commit
           source
         end
 
@@ -1676,15 +1547,19 @@ module Squared
             source(banner: false)
             return
           when :oneline
-            format = flag.to_s
+            format = 'oneline'
           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
+          if format
+            case (val = format.downcase)
+            when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
+              cmd << basic_option('format', val)
+            else
+              if format.start_with?(/t?format:/) || format.include?('%')
+                cmd << quote_option('pretty', format)
+              else
+                opts << format
+              end
+            end
           end
           op = OptionPartition.new(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff], cmd,
                                    project: self,
@@ -1697,7 +1572,7 @@ module Squared
           cmd, opts = git_session('rev-parse', opts: opts)
           case flag
           when :commit
-            cmd << (size.to_i.zero? ? '--verify' : basic_option('short', [size.to_i, 5].max))
+            cmd << ((n = size.to_i) > 0 ? basic_option('short', [n, 5].max) : '--verify')
             append_commit(ref, head: true)
           when :branch
             cmd << '--abbrev-ref'
@@ -1718,7 +1593,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.add_quote(remote) if remote
+          op << shell_quote(remote) if remote
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: op.extras, prefix: "refs/#{flag}/")
@@ -1728,7 +1603,6 @@ 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)
@@ -1737,17 +1611,10 @@ module Squared
 
         def git(flag, opts = [])
           cmd, opts = git_session(flag, opts: opts)
-          op = OptionPartition.new(opts, OPT_GIT[:git].fetch(flag, []) + OPT_GIT.fetch(flag, []), cmd,
-                                   project: self, no: OPT_GIT[:no][flag], first: case flag
-                                                                                 when :blame, :revert
-                                                                                   nil
-                                                                                 else matchpathspec
-                                                                                 end)
+          list = OPT_GIT[:git].fetch(flag, []) + OPT_GIT.fetch(flag, [])
+          op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GIT[:no][flag],
+                                                    first: flag == :revert ? nil : matchpathspec)
           case flag
-          when :blame
-            raise_error 'no file found' unless (n = op.index { |s| basepath(s).file? })
-            op << '--' << shell_quote(basepath(op.delete_at(n)))
-            op.clear
           when :revert
             if VAL_GIT[:rebase][:send].any? { |val| op.arg?(val) }
               op.clear
@@ -1756,34 +1623,35 @@ module Squared
             else
               append_commit(*op.extras)
             end
-          when :add
+          when :add, :clean
             if flag == :add && !op.arg?('pathspec-from-file')
-              grep, list = op.partition { |val| OptionPartition.pattern?(val) }
-              unless grep.empty? && !list.empty?
+              grep, list = op.extras.partition { |val| val.start_with?(':') && val.end_with?(':') }
+              if list.empty? || !grep.empty?
+                red = color(:red)
                 grep.map! { |val| Regexp.new(val[1..-2]) }
-                files = []
-                status_data.each do |a, b|
-                  next if b.strip.empty? || (!grep.empty? && grep.none? { |pat| pat.match?(a) })
+                files = status_data.map! do |a, b|
+                  next unless grep.empty? || grep.any? { |pat| pat.match?(a) }
 
-                  files << "#{sub_style(b, styles: color(:red))} #{a}"
+                  "#{sub_style(b, styles: red)} #{a}"
                 end
+                .compact
                 unless files.empty?
-                  files = choice_index('Select files', files, multiple: true, trim: /^\S+\s/,
-                                                              accept: [['Add?', false, true]])
+                  files = choice_index('Select files', files, multiple: true, force: true, trim: /^\S+\s/,
+                                                              accept: 'Add?')
                 end
                 op.swap(list + files)
               end
             end
-            return source(git_session('status -s'), banner: false) unless append_pathspec(op.extras)
-
-            print_success if success?(source, flag == :add && !op.arg?('verbose'))
+            append_pathspec op.extras
+            verbose = flag == :add && !op.arg?('verbose')
+            print_success if success?(source) && verbose
             return
           when :mv
             refs = projectmap op.extras
             raise_error 'no source/destination' unless refs.size > 1
             op.merge(refs)
-          when :rm, :clean
-            append_pathspec(op.extras, expect: flag == :rm)
+          when :rm
+            append_pathspec(op.extras, expect: true)
           end
           source(sync: false, stderr: true)
         end
@@ -1803,47 +1671,40 @@ module Squared
         private
 
         def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
-                   multiple: false, hint: nil, from: nil, send: :system, **kwargs)
+                   multiple: false, **kwargs)
           cmd = cmd.target if cmd.is_a?(OptionPartition)
-          if io && banner == false
-            from = nil
-            banner = nil
-          else
-            if banner
-              banner = nil unless banner? && !multiple
-              args = true
+          banner = nil if banner && (multiple || !banner?)
+          if cmd.respond_to?(:done)
+            if io && banner == false
+              from = nil
+            elsif !from && (from = cmd.drop(1).find { |val| val.match?(/\A[a-z]{1,2}[a-z\-]*\z/) })
+              from = :"git:#{from}"
             end
-            if cmd.respond_to?(:done)
-              if from.nil? && (from = cmd.drop(1).find { |val| val.match?(/\A[a-z]{1,2}[a-z-]*\z/) })
-                from = :"git:#{from}"
-              end
-              banner &&= cmd.temp { |val| val.start_with?('--work-tree') || val.start_with?('--git-dir') }
-            end
-            from = nil if from == false
+            banner &&= cmd.temp { |val| val.start_with?('--work-tree') || val.start_with?('--git-dir') }
           end
           cmd = session_done cmd
           log&.info cmd
+          on :first, from
           banner = if banner
-                     banner = (banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), '')
-                     format_banner(hint ? "#{banner} (#{hint})" : banner)
+                     format_banner((banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), ''), banner: true)
                    end
-          on :first, from
           begin
             if io
               return `#{cmd}` if stdout
 
-              return args ? [IO.popen(cmd), banner || '', from] : IO.popen(cmd)
-            elsif stdin? ? sync : stdout
+              return banner ? [IO.popen(cmd), banner, from] : IO.popen(cmd)
+            end
+            if stdin? ? sync : stdout
               print_item banner unless multiple
-              ret = `#{cmd}`.chomp
+              ret = `#{cmd}`
               if !ret.empty?
                 puts ret
               elsif success?(!banner.nil?)
                 print_success
               end
-            elsif !kwargs[:sub] && (sync || (!exception && !stderr))
+            elsif sync || (!exception && !stderr)
               print_item banner unless multiple
-              ret = shell(cmd, name: send, exception: exception)
+              ret = shell(cmd, exception: exception)
             else
               require 'open3'
               if stderr
@@ -1861,7 +1722,11 @@ module Squared
               end
             end
           rescue StandardError => e
-            on_error(e, from, pass: true)
+            log&.error e
+            ret = on(:error, from, e)
+            raise if exception && ret != true
+
+            warn log_message(Logger::WARN, e, pass: true) if warning?
             nil
           else
             on :last, from
@@ -1870,7 +1735,16 @@ module Squared
         end
 
         def write_lines(data, grep: [], prefix: nil, sub: nil, banner: nil, loglevel: nil, pass: false, first: false)
-          grep = grep.empty? ? nil : matchmap(grep, prefix)
+          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
           sub = nil if stdin?
           ret = 0
           out = []
@@ -1901,11 +1775,11 @@ 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 stdout?
+          elsif verbose
             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}",
-                              sub: [{ pat: /^(\d+)(.+)$/, styles: styles }])
+                              sub: [pat: /^(\d+)(.+)$/, styles: styles])
           end
           on :last, from
         end
@@ -1921,7 +1795,7 @@ module Squared
           end
           args = []
           args << quote_option('sort', sort) if sort
-          args << basic_option('count', env('GIT_COUNT', ARG[:CHOICE])) if count
+          args << shell_option('count', env('GIT_COUNT', ARG[:CHOICE])) if count
           choice_index(msg, foreachref(type, *args, format: format), trim: trim, **kwargs)
         end
 
@@ -1944,11 +1818,12 @@ module Squared
           glob = kwargs.fetch(:include, [])
           pass = kwargs.fetch(:exclude, [])
           ret = {}
-          status_data(*args).each do |file,|
+          status_data(*args).each do |line|
+            file = line.first
             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) }
 
-            ret[file] = algorithm.hexdigest(File.read(basepath(file)))
+            ret[file] = algorithm.hexdigest(File.read(path + file))
           end
           ret
         end
@@ -1964,7 +1839,7 @@ module Squared
         end
 
         def append_pull(opts, list, target: @session, flag: nil, no: nil, remote: nil, from: nil)
-          target << '--force' if option('force', 'f', target: target)
+          target << '--force' if option('force', target: target)
           append_submodules(target: target, from: from)
           return if !remote && opts.empty?
 
@@ -1976,11 +1851,13 @@ module Squared
               when 'rebase'
                 op << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
               when 'shallow-since'
-                op.append?($1) { Date.parse($2).strftime('%F %T') }
+                next unless (val = Date.parse($2))
+
+                op << quote_option($1, val.strftime('%F %T'))
               when 'recurse-submodules'
-                op.append?($1, $2, type: :basic)
+                op << basic_option($1, $2) unless op.arg?('recurse-submodules')
               when 'refspec'
-                refspec << shell_quote($2)
+                refspec << shell_escape($2, quote: true)
               end
             elsif op.arg?('multiple')
               op.found << opt
@@ -1988,7 +1865,7 @@ module Squared
               op.errors << opt
             end
           end
-          op << '--verbose' if (flag || from == :fetch) && stdout? && !op.arg?('quiet')
+          op << '--verbose' if (flag || from == :fetch) && verbose && !op.arg?('quiet')
           if remote
             op.append(remote, delim: true)
             if (val = option('refspec', target: target, strict: true))
@@ -1998,12 +1875,12 @@ module Squared
             end
             op.delete('--all')
           elsif op.arg?('multiple')
-            op.add_quote(*op.found)
+            op.swap.merge(op.map! { |opt| shell_escape(opt, quote: true) })
             return
           elsif option('all')
-            op << '--all'
+            cmd << '--all'
           end
-          op.clear(errors: true, subject: flag) if flag
+          op.clear(errors: true, subject: flag.to_s) if flag
         end
 
         def append_commit(*val, target: @session, head: false)
@@ -2018,28 +1895,20 @@ module Squared
         def append_pathspec(files = [], target: @session, expect: false, parent: false, pass: true)
           if session_arg?('pathspec-from-file', target: target)
             option_clear files
-            true
           else
-            if files.empty? && (val = option('pathspec', target: target))
-              files = split_escape val
-            end
+            option('pathspec', target: target) { |val| files = split_escape val } if files.empty?
             files = projectmap(files, parent: parent, pass: pass)
             if !files.empty?
               target << '--' << files.join(' ')
-              true
             elsif expect
               raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree')
-            else
-              false
             end
           end
         end
 
         def append_message(val = nil, target: @session)
           val = messageopt if val.to_s.empty?
-          return unless val
-
-          target << quote_option('message', val)
+          target << quote_option('message', val) if val
         end
 
         def append_head(val = nil, target: @session)
@@ -2049,61 +1918,51 @@ module Squared
         end
 
         def append_submodules(target: @session, from: nil)
-          return unless (val = option('recurse-submodules', target: target, ignore: false))
-
-          if from == :clone
-            case val
-            when '0', 'false'
-              target << '--no-recurse-submodules'
-            when '1', 'true'
-              target << '--recurse-submodules'
-            else
-              projectmap(split_escape(val)).each do |path|
-                target << basic_option('recurse-submodules', path)
+          option('recurse-submodules', target: target, ignore: false) do |val|
+            if from == :clone
+              case val
+              when '0', 'false'
+                target << '--no-recurse-submodules'
+              when '1', 'true'
+                target << '--recurse-submodules'
+              else
+                projectmap(split_escape(val)).each do |path|
+                  target << basic_option('recurse-submodules', path)
+                end
               end
+            else
+              target << case val
+                        when 'no', '0', 'false'
+                          '--no-recurse-submodules'
+                        when 'yes', 'on-demand'
+                          "--recurse-submodules=#{val}"
+                        else
+                          '--recurse-submodules'
+                        end
             end
-          else
-            target << case val
-                      when 'no', '0', 'false'
-                        '--no-recurse-submodules'
-                      when 'yes', 'on-demand'
-                        "--recurse-submodules=#{val}"
-                      else
-                        '--recurse-submodules'
-                      end
           end
         end
 
         def foreachref(path, *args, format: nil)
-          path = Array(path).map! { |val| "refs/#{val}" }
-          format &&= quote_option('format', format)
-          ret = git_spawn('for-each-ref', format, *args, *path, stdout: workspace.windows?)
-          ret.is_a?(String) ? ret.lines : ret
+          path = as_a(path).map! { |val| "refs/#{val}" }
+          git_spawn('for-each-ref', format && quote_option('format', format), *args, *path, stdout: false)
         end
 
         def git_session(*cmd, opts: nil, worktree: true, **kwargs)
-          dir = worktree ? [quote_option('work-tree', path), quote_option('git-dir', gitpath)] : []
+          dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
           return session('git', *dir, *cmd, **kwargs) unless opts
 
           op = OptionPartition.new(opts, OPT_GIT[:common], dir, project: self)
-          [session('git', *op.to_a, *cmd, **kwargs), op.extras]
+          ret = session('git', *op.to_a, *cmd, **kwargs)
+          [ret, op.extras]
         end
 
         def git_output(*cmd, **kwargs)
           git_session(*cmd, main: false, options: false, **kwargs)
         end
 
-        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)
+        def git_spawn(*cmd, stdout: true)
+          source(cmd.first.is_a?(Set) ? cmd.first : git_output(*cmd), io: true, banner: false, stdout: stdout)
         end
 
         def dryrun?(*, target: @session, **)
@@ -2118,35 +1977,32 @@ module Squared
           target.include?('--quiet') || (target.include?('-q') && stripext(target.first) == 'git')
         end
 
-        def gitpath(*args)
-          path.join('.git', *args)
+        def gitpath
+          path + '.git'
         end
 
         def repotrack(origin, branch, quote: true)
-          unless origin && branch && (i = origin.index('/'))
-            raise_error(ArgumentError, "missing #{origin ? 'branch' : 'remote'} name", hint: origin)
-          end
-          branch = "#{branch}:#{origin[(i + 1)..-1]}" unless origin.end_with?("/#{branch}")
-          ret = [origin[0..(i - 1)], branch]
-          quote ? ret.map! { |val| shell_quote(val) } : ret
+          i = origin.index('/')
+          branch = "#{branch}:#{origin[i + 1..-1]}" unless origin.end_with?("/#{branch}")
+          [origin[0..i - 1], branch].tap { |ret| ret.map! { |val| shell_quote(val) } if quote }
         end
 
         def commithash(val)
-          val[/\A:(\h{5,40})\z/, 1] || val[/\A#\{(\h{5,40})\}\z/, 1]
+          val[/\A:(\h{5,40})\z/, 1]
         end
 
         def commithead(val)
           return val unless (s = matchhead(val))
 
-          s.match?(/^\d/) ? "@~#{s}" : "@#{s}"
+          s.start_with?(/\d/) ? "@~#{s}" : "@#{s}"
         end
 
         def matchhead(val)
-          val && val =~ /^(?:(?:HEAD|@)([~^]\d*)?|H(\d+))$/ ? $2 || $1 || '' : nil
+          val =~ /^(?:(?:HEAD|@)([~^]\d*)?|H(\d+))$/ ? $2 || $1 || '' : nil
         end
 
         def matchpathspec
-          [/\A[^a-z\d-]+/i, %r{\A[^=\\/*]*[\\/*]}, /\A--\z/]
+          [/\A[^a-z\d-]+/i, %r{\A[^=\\/*]*[\\/*]}]
         end
 
         def messageopt