squared 0.2.10 → 0.3.0

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

@@ -72,23 +72,111 @@ module Squared
 
     module Project
       class Git < Base
-        FOR_FETCH = %w[atomic multiple negotiate-only prefetch progress prune-tags refetch].freeze
-        NO_FETCH = %w[all ipv4 ipv6 recurse-submodules show-forced-updates tags].freeze
-        FNO_FETCH = %w[auto-gc auto-maintenance write-commit-graph write-fetch-head].freeze
-        OPT_FETCH = (FOR_FETCH + NO_FETCH + FNO_FETCH +
-                     %w[append dry-run force keep prune quiet set-upstream unshallow update-shallow verbose
-                        deepen=i depth=i jobs=i negotiation-tip=s refmap=s recurse-submodules=s server-option=s
-                        shallow-exclude=s shallow-since=d upload-pack=s]).freeze
-        NO_PULL = %w[allow-unrelated-histories autostash commit edit ff signoff squash stat verify verify-signatures
-                     gpg-sign=? log=? rebase=?].freeze
-        OPT_PULL = (NO_PULL + %w[ff-only signoff=s strategy=s strategy-option=s]).freeze
-        OPT_REBASE = %w[continue skip abort quit].freeze
-        VAL_REBASE = %w[true false merges interactive].freeze
-        NO_BRANCH = %w[abbrev=i color=? column=? track=?].freeze
-        OPT_BRANCH = (NO_BRANCH + %w[all create-reflog ignore-case quiet remotes verbose
-                                     contains=s format=s merged=s no-contains=s no-merged=s points-at=s sort=s]).freeze
-        private_constant :FOR_FETCH, :NO_FETCH, :FNO_FETCH, :OPT_FETCH, :NO_PULL, :OPT_PULL, :OPT_REBASE, :VAL_REBASE,
-                         :NO_BRANCH, :OPT_BRANCH
+        OPT_GIT = {
+          branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose abbrev=i color=b column=b
+                     contains=e format=q merged=e no-contains=e no-merged=e points-at=e u|set-upstream-to=e 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 orphan=e ours theirs conflict=b pathspec-from-file=p
+                       t|track=b].freeze,
+          diff: {
+            base: %w[0 1|base 2|ours 3|theirs].freeze,
+            show: %w[s exit-code histogram].freeze
+          }.freeze,
+          fetch: {
+            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok recurse-submodules=s
+                     recurse-submodules-default=b].freeze,
+            pull: %w[4 6 n t a|append atomic dry-run f|force k|keep n|negotiate-only prefetch p|prune q|quiet
+                     set-upstream unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q
+                     refmap=q o|server-option=e shallow-exclude=e shallow-since=s upload-pack=e].freeze
+          }.freeze,
+          log: {
+            base: %w[all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
+                     cherry-pick clear-decorations date-order dense do-walk exclude-first-parent-only E|extended-regexp
+                     first-parent F|fixed-strings follow full-diff full-history ignore-missing invert-grep left-only
+                     merge log-size no-max-parents no-min-parents not P|perl-regexp reflog i|regexp-ignore-case
+                     remove-empty reverse right-only simplify-by-decoration simplify-merges single-worktree show-pulls
+                     source sparse stdin topo-order g|walk-reflogs after=q ancestry-path=e? author=q before=q
+                     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 L=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=q pretty=q?
+                       show-linear-break=q?].freeze,
+            diff: %w[p R u z l=i G=q O=q S=q 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 ita-invisible-in-index minimal name-only
+                     name-status no-color-moved-ws no-prefix no-renames numstat patch-with-raw patch-with-stat patience
+                     pickaxe-all pickaxe-regex raw shortstat summary a|text abbrev=i? anchored=q B|break-rewrites=e?
+                     color=b color-moved=b color-moved-ws=b color-words=q? diff-algorithm=b diff-filter=e? X|dirstat=q?
+                     dirstat-by-file=q? dst-prefix=q C|find-copies=i? find-object=e M|find-renames=i?
+                     I|ignore-matching-lines=q ignore-submodules=b inter-hunk-context=i line-prefix=q output=p
+                     output-indicator-context=q output-indicator-new=q output-indicator-old=q relative=p rotate-to=p
+                     skip-to=p src-prefix=q stat=q? stat-width=i stat-name-width=i stat-count=i submodule=b? U|unified=i
+                     word-diff=b? word-diff-regex=q ws-error-highligt=q].freeze
+          }.freeze,
+          ls_files: %w[z debug deduplicate directory eol error-unmatch exclude-standard full-name k|killed
+                       no-empty-directory recurse-submodules sparse s|stage u|unmerged abbrev=i x|exclude=q
+                       X|exclude-from=p exclude-per-directory=p format=q with-tree=q].freeze,
+          ls_remote: %w[exit-code get-url q|quiet o|server-option=e symref sort=q upload-pack=e].freeze,
+          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=e log=i rebase=s s|strategy=b
+                   X|strategy-option=e].freeze,
+          rebase: %w[n C=i allow-empty-message apply committer-date-is-author-date edit-todo f|force-rebase ignore-date
+                     ignore-whitespace i|interactive keep-base m merge no-ff q|quiet quit r|rebase-merges=b?
+                     reset-author-date root show-current-patch signoff v|verbose empty=b S|gpg-sign=b onto=e
+                     s|strategy=b X|strategy-option=b whitespace=e].freeze,
+          reset: %w[N pathspec-file-nul q|quiet pathspec-from-file=p].freeze,
+          restore: %w[ignore-unmerged ignore-skip-worktree-bits m|merge ours p|patch pathspec-file-nul S|staged theirs
+                      W|worktree conflict=b pathspec-from-file=p s|source=q].freeze,
+          rev_parse: {
+            output: %w[absolute-git-dir all flags git-common-dir git-dir is-bare-repository is-inside-git-dir
+                       is-inside-work-tree is-shallow-repository local-env-vars no-flags no-revs not q|quiet sq
+                       revs-only shared-index-path show-cdup show-prefix show-toplevel show-superproject-working-tree
+                       sq-quote symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q default=e
+                       disambiguate=b exclude=q exclude-hidden=b glob=q git-path=p path-format=b? prefix=q branches=q?
+                       remotes=q? resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].freeze,
+            parseopt: %w[keep-dashdash stop-at-non-option stuck-long].freeze
+          }.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,
+          stash: {
+            common: %w[q|quiet].freeze,
+            push: %w[a|all u|include-untracked k|keep-index no-keep-index p|patch S|staged m|message=q
+                     pathspec-from-file=p].freeze,
+            pop: %w[index].freeze,
+            apply: %w[index].freeze
+          }.freeze,
+          tag: %w[create-reflog column=b contains=e? format=q merged=e? n=i no-contains=e? no-merged=e? points-at=q
+                  sort=q].freeze,
+          no: {
+            fetch: {
+              base: %w[auto-gc auto-maintenance write-commit-graph write-fetch-head].freeze,
+              pull: %w[all ipv4 ipv6 recurse-submodules show-forced-updates tags].freeze
+            },
+            log: {
+              base: %w[decorate mailmap merges use-mailmap].freeze,
+              show: %w[abbrev-commit expand-tabs notes].freeze,
+              diff: %w[color color-moved ext-diff indent-heuristic patch relative rename-empty textconv].freeze
+            }.freeze,
+            pull: %w[autostash commit edit ff log signoff squash stat verify verify-signatures gpg-sign rebase].freeze,
+            tag: %w[column].freeze,
+            branch: %w[color-moved column color track].freeze,
+            checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
+            rebase: %w[autosquash autostash fork-point gpg-sign keep-empty reapply-cherry-picks reschedule-failed-exec
+                       rerere-autoupdate stat update-refs verify].freeze,
+            reset: %w[refresh].freeze,
+            restore: %w[overlay progress recurse-submodules].freeze,
+            show: %w[standard-notes].freeze
+          }.freeze
+        }
+        VAL_GIT = {
+          rebase: {
+            send: %w[continue skip abort quit].freeze,
+            value: %w[true false merges interactive].freeze
+          }.freeze,
+          reset: %w[soft mixed hard merge keep recurse-submodules no-recurse-submodules].freeze
+        }
+        private_constant :OPT_GIT, :VAL_GIT
 
         class << self
           include Rake::DSL
@@ -134,21 +222,22 @@ module Squared
         end
 
         @@tasks[ref] = {
-          'checkout' => %i[branch track detach force merge].freeze,
-          'commit' => %i[add amend amend-orig all no-all].freeze,
-          'diff' => %i[head cached branch files between contain].freeze,
-          'pull' => %i[origin remote].freeze,
-          'fetch' => %i[origin remote].freeze,
-          'stash' => %i[push pop apply list clear].freeze,
-          'rebase' => %i[onto root send].freeze,
           'branch' => %i[create set delete move copy list edit current].freeze,
-          'refs' => %i[heads tags].freeze,
-          'files' => %i[cached modified deleted others].freeze,
-          'reset' => %i[head patch mode].freeze,
+          'checkout' => %i[commit branch track detach path].freeze,
+          'commit' => %i[add all amend amend-orig].freeze,
+          'diff' => %i[head cached branch files view between contain].freeze,
+          'fetch' => %i[origin remote].freeze,
+          'files' => %i[cached modified deleted others ignored].freeze,
+          'log' => %i[view between contain].freeze,
+          'pull' => %i[origin remote].freeze,
+          'rebase' => %i[branch onto send].freeze,
+          'refs' => %i[heads tags remote].freeze,
+          'reset' => %i[commit index patch mode].freeze,
           'restore' => %i[source worktree staged overlay].freeze,
-          'rev' => %i[commit branch].freeze,
+          'rev' => %i[commit branch output parseopt].freeze,
           'show' => %i[format oneline].freeze,
-          'tag' => %i[add delete list merged].freeze
+          'stash' => %i[push pop apply drop list].freeze,
+          'tag' => %i[add delete list].freeze
         }.freeze
 
         def initialize(*, **)
@@ -173,93 +262,96 @@ module Squared
                   case action
                   when 'pull', 'fetch'
                     if flag == :remote
-                      if @@task_desc
-                        format_desc(action, flag, ['refspec=s'] + (action == 'pull' ? OPT_PULL : OPT_FETCH),
-                                    before: 'remote')
-                      end
+                      format_desc(action, flag, 'remote,opts*')
                       task flag, [:remote] do |_, args|
                         remote = param_guard(action, flag, args: args, key: :remote)
-                        __send__(action, flag, remote: remote, opts: args.extras)
+                        __send__(action, flag, args.extras, remote: remote)
                       end
                     else
-                      format_desc(action, flag, action == 'pull' ? OPT_PULL : OPT_FETCH)
+                      format_desc action, flag, 'opts*'
                       task flag do |_, args|
-                        __send__(action, flag, opts: args.to_a)
+                        __send__ action, flag, args.to_a
                       end
                     end
-                  when 'commit', 'restore'
+                  when 'commit'
                     case flag
                     when :all
                       format_desc action, flag, 'message?'
                       task flag, [:message] do |_, args|
                         commit(flag, message: args.fetch(:message, nil))
                       end
-                    when :source
-                      format_desc action, flag, 'tree,pathspec*'
+                    else
+                      format_desc action, flag, 'pathspec+'
+                      task flag do |_, args|
+                        refs = param_guard(action, flag, args: args.to_a)
+                        commit(flag, refs: refs)
+                      end
+                    end
+                  when 'restore'
+                    if flag == :source
+                      format_desc action, flag, 'tree,opts*,pathspec*'
                       task flag, [:tree] do |_, args|
                         tree = param_guard(action, flag, args: args, key: :tree)
                         restore(flag, args.extras, tree: tree)
                       end
                     else
-                      format_desc action, flag, 'pathspec+'
+                      format_desc action, flag, 'opts*,pathspec+'
                       task flag do |_, args|
-                        files = param_guard(action, flag, args: args.to_a)
-                        __send__ action, flag, files
+                        restore flag, args.to_a
                       end
                     end
                   when 'tag'
                     case flag
                     when :list
-                      format_desc action, flag, 'pattern*'
+                      format_desc action, flag, 'opts*,pattern*'
                       task flag do |_, args|
                         tag flag, args.to_a
                       end
-                    when :merged
-                      format_desc action, flag, 'commit,pattern*'
-                      task flag, [:commit] do |_, args|
-                        commit = param_guard(action, flag, args: args, key: :commit)
-                        tag(flag, args.extras, commit: commit)
-                      end
                     when :delete
                       format_desc action, flag, 'name+'
                       task flag do |_, args|
-                        name = param_guard(action, flag, args: args.to_a)
-                        tag flag, name
+                        refs = param_guard(action, flag, args: args.to_a)
+                        tag(flag, refs: refs)
                       end
                     when :add
                       format_desc action, flag, 'name,message?,commit?'
                       task flag, [:name, :message, :commit] do |_, args|
                         name = param_guard(action, flag, args: args, key: :name)
-                        tag(flag, [name], message: args.message, commit: args.commit)
+                        tag(flag, refs: [name], message: args.message, commit: args.commit)
                       end
                     end
                   when 'stash'
-                    if flag == :push
-                      format_desc action, flag, 'pathspec*'
-                      task flag do |_, args|
-                        stash flag, args.to_a
-                      end
+                    if flag == :list
+                      format_desc action, flag
                     else
-                      format_desc action, flag, 'commit?'
-                      task flag, [:commit] do |_, args|
-                        stash(flag, commit: args.commit)
-                      end
+                      format_desc(action, flag, '*opts', after: flag == :push ? 'pathspec*' : 'commit?')
                     end
-                  when 'diff'
+                    task flag do |_, args|
+                      stash flag, args.to_a
+                    end
+                  when 'log', 'diff'
                     case flag
-                    when :head
-                      format_desc action, flag, 'index?=0,pathspec*'
-                      task flag do |_, args|
-                        files = args.to_a
-                        diff(flag, files, index: /\A\d+\z/.match?(files[0]) && !option('index') ? files.shift.to_i : 0)
+                    when :view, :between, :contain
+                      if flag == :view && action == 'log'
+                        format_desc action, flag, '(^)commit*,pathspec*,opts*'
+                        task flag do |_, args|
+                          logx flag, args.to_a
+                        end
+                      else
+                        format_desc action, flag, 'commit1,commit2,pathspec*,opts*'
+                        task flag, [:commit1, :commit2] do |_, args|
+                          commit1 = param_guard(action, flag, args: args, key: :commit1)
+                          commit2 = param_guard(action, flag, args: args, key: :commit2)
+                          __send__(action == 'log' ? :logx : :diff, flag, args.extras, range: [commit1, commit2])
+                        end
                       end
-                    when :cached
-                      format_desc action, flag, 'pathspec*'
+                    when :head, :cached
+                      format_desc action, flag, 'opts*,pathspec*'
                       task flag do |_, args|
                         diff flag, args.to_a
                       end
                     when :branch
-                      format_desc action, flag, 'name,pathspec*'
+                      format_desc action, flag, 'name,opts*,pathspec*'
                       task flag, [:name] do |_, args|
                         branch = param_guard(action, flag, args: args, key: :name)
                         diff(flag, args.extras, branch: branch)
@@ -269,14 +361,7 @@ module Squared
                       task flag, [:path1, :path2] do |_, args|
                         path1 = param_guard(action, flag, args: args, key: :path1)
                         path2 = param_guard(action, flag, args: args, key: :path2)
-                        diff flag, [path1, path2]
-                      end
-                    else
-                      format_desc action, flag, 'commit1,commit2,pathspec*'
-                      task flag, [:commit1, :commit2] do |_, args|
-                        commit1 = param_guard(action, flag, args: args, key: :commit1)
-                        commit2 = param_guard(action, flag, args: args, key: :commit2)
-                        diff(flag, args.extras, range: [commit1, commit2])
+                        diff(flag, refs: [path1, path2])
                       end
                     end
                   when 'checkout'
@@ -310,13 +395,19 @@ module Squared
                         origin = param_guard(action, flag, args: args, key: :origin)
                         checkout(flag, branch: args.name, origin: origin)
                       end
+                    when :commit
+                      format_desc action, flag, 'branch/commit,opts*'
+                      task flag, [:commit] do |_, args|
+                        commit = param_guard(action, flag, args: args, key: :commit)
+                        checkout(flag, commit: commit)
+                      end
                     when :detach
                       format_desc action, flag, 'branch/commit?'
                       task flag, [:commit] do |_, args|
                         checkout(flag, commit: args.commit)
                       end
-                    else
-                      format_desc action, flag, 'pathspec*'
+                    when :path
+                      format_desc action, flag, 'opts*,pathspec*'
                       task flag do |_, args|
                         checkout flag, args.to_a
                       end
@@ -326,11 +417,11 @@ module Squared
                     when :create
                       format_desc action, flag, 'name,ref?=HEAD'
                       task flag, [:name, :ref] do |_, args|
-                        name = param_guard(action, flag, args: args, key: :name)
-                        branch(flag, target: name, ref: args.ref)
+                        target = param_guard(action, flag, args: args, key: :name)
+                        branch(flag, target: target, ref: args.ref)
                       end
                     when :set
-                      format_desc(action, flag, '(!)upstream,name?')
+                      format_desc(action, flag, '(^)upstream,name?')
                       task flag, [:upstream, :name] do |_, args|
                         upstream = param_guard(action, flag, args: args, key: :upstream)
                         branch(flag, target: args.name, ref: upstream)
@@ -338,8 +429,8 @@ module Squared
                     when :delete
                       format_desc action, flag, '(^~)name+'
                       task flag, [:name] do |_, args|
-                        name = param_guard(action, flag, args: args.to_a)
-                        branch flag, name
+                        refs = param_guard(action, flag, args: args.to_a)
+                        branch(flag, refs: refs)
                       end
                     when :edit
                       format_desc action, flag, 'name?'
@@ -347,9 +438,9 @@ module Squared
                         branch(flag, target: args.name)
                       end
                     when :list
-                      format_desc(action, flag, OPT_BRANCH, before: 'pattern*')
+                      format_desc action, flag, 'opts*,pattern*'
                       task flag do |_, args|
-                        branch(flag, opts: args.to_a)
+                        branch flag, args.to_a
                       end
                     when :current
                       format_desc action, flag
@@ -357,74 +448,109 @@ module Squared
                         branch flag
                       end
                     else
-                      format_desc action, flag, 'newbranch,oldbranch?'
-                      task flag, [:newbranch, :oldbranch] do |_, args|
-                        newbranch = param_guard(action, flag, args: args, key: :newbranch)
-                        branch flag, [args.oldbranch, newbranch]
+                      format_desc action, flag, 'branch,oldbranch?'
+                      task flag, [:branch, :oldbranch] do |_, args|
+                        branch = param_guard(action, flag, args: args, key: :branch)
+                        branch(flag, refs: [args.oldbranch, branch])
                       end
                     end
                   when 'reset'
                     case flag
-                    when :mode
-                      if @@task_desc
-                        format_desc(action, flag, %w[soft mixed hard merge keep {no-}submodules], after: 'ref?=HEAD',
-                                                                                                  arg: false)
+                    when :commit
+                      format_desc action, flag, 'branch/commit,opts*'
+                      task flag, [:commit] do |_, args|
+                        commit = param_guard(action, flag, args: args, key: :commit)
+                        reset(flag, args.extras, commit: commit)
+                      end
+                    when :index
+                      format_desc action, flag, 'opts*,pathspec*'
+                      task flag do |_, args|
+                        reset flag, args.to_a
                       end
+                    when :mode
+                      format_desc action, flag, 'mode,ref?=HEAD'
                       task flag, [:mode, :ref] do |_, args|
                         mode = param_guard(action, flag, args: args, key: :mode)
                         reset(flag, mode: mode, ref: args.ref)
                       end
-                    else
-                      format_desc action, flag, 'ref,pathspec+'
+                    when :patch
+                      format_desc action, flag, 'ref,pathspec*'
                       task flag, [:ref] do |_, args|
-                        files = param_guard(action, flag, args: args.extras)
-                        reset(flag, files, ref: args.ref)
+                        ref = param_guard(action, flag, args: args, key: :ref)
+                        reset(flag, refs: args.extras, ref: ref)
                       end
                     end
                   when 'show'
                     case flag
                     when :oneline
-                      format_desc action, flag, 'object*'
+                      format_desc action, flag, 'opts*,object*'
                       task flag do |_, args|
-                        show(args.to_a, format: 'oneline', opts: { 'abbrev-commit': true })
+                        show 'oneline', args.to_a.push('abbrev-commit')
                       end
                     when :format
-                      format_desc action, flag, 'format?,object*'
+                      format_desc action, flag, 'format?,opts*,object*'
                       task flag, [:format] do |_, args|
-                        show(args.extras, format: args.format)
+                        show args.format, args.extras
                       end
                     end
                   when 'rebase'
                     case flag
+                    when :branch
+                      format_desc action, flag, 'opts*,upstream?,branch?'
+                      task flag do |_, args|
+                        args = param_guard(action, flag, args: args.to_a)
+                        rebase flag, args
+                      end
                     when :onto
-                      format_desc action, flag, 'commit,upstream,branch?=HEAD'
+                      format_desc action, flag, 'branch/commit,upstream,branch?=HEAD'
                       task flag, [:commit, :upstream, :branch] do |_, args|
                         commit = param_guard(action, flag, args: args, key: :commit)
                         upstream = param_guard(action, flag, args: args, key: :upstream)
                         rebase(flag, commit: commit, upstream: upstream, branch: args.branch)
                       end
-                    when :root
-                      format_desc action, flag, 'branch,onto?'
-                      task flag, [:branch, :onto] do |_, args|
-                        branch = param_guard(action, flag, args: args, key: :branch)
-                        rebase(flag, commit: args.onto, branch: branch)
-                      end
                     when :send
-                      format_desc(action, flag, OPT_REBASE, arg: nil)
+                      format_desc(action, flag, VAL_GIT[:rebase][:send], arg: nil)
                       task flag, [:command] do |_, args|
                         command = param_guard(action, flag, args: args, key: :command)
                         rebase(flag, command: command)
                       end
                     end
                   when 'rev'
-                    format_desc(action, flag, "ref?=HEAD#{flag == :commit ? ',size?' : ''}")
-                    task flag, [:ref, :size] do |_, args|
-                      rev_parse(flag, ref: args.ref, size: args.size)
+                    case flag
+                    when :commit
+                      format_desc action, flag, 'ref?=HEAD,size?'
+                      task flag, [:ref, :size] do |_, args|
+                        ref = args.ref
+                        size = args.size
+                        if !size && ref.to_i > 0
+                          size = ref
+                          ref = nil
+                        end
+                        rev_parse(flag, ref: ref, size: size)
+                      end
+                    when :branch
+                      format_desc action, flag, 'ref?=HEAD'
+                      task flag, [:ref] do |_, args|
+                        rev_parse(flag, ref: args.ref)
+                      end
+                    else
+                      format_desc action, flag, 'opts*,args*'
+                      task flag do |_, args|
+                        rev_parse flag, args.to_a
+                      end
                     end
                   when 'refs', 'files'
-                    format_desc action, flag, 'grep?=pattern'
-                    task flag, [:grep] do |_, args|
-                      __send__(action == 'refs' ? :ls_remote : :ls_files, flag, grep: args.fetch(:grep, nil))
+                    if flag == :remote
+                      format_desc action, flag, 'remote,opts*,pattern*'
+                      task flag, [:remote] do |_, args|
+                        remote = param_guard(action, flag, args: args, key: :remote)
+                        ls_remote(flag, args.to_a.drop(1), remote: remote)
+                      end
+                    else
+                      format_desc action, flag, 'opts*,pattern*'
+                      task flag do |_, args|
+                        __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
+                      end
                     end
                   end
                 end
@@ -438,21 +564,18 @@ module Squared
           super
         end
 
-        def pull(flag = nil, sync: invoked_sync?('pull', flag), remote: nil, opts: [])
+        def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
           cmd = git_session 'pull'
-          if flag == :rebase
-            cmd << '--rebase'
-            cmd << '--autostash' if option('autostash')
-          elsif (val = option('rebase', ignore: false))
+          if (val = option('rebase', ignore: false))
             cmd << case val
                    when '0'
                      '--no-rebase'
                    else
-                     VAL_REBASE.include?(val) ? basic_option('rebase', val) : '--rebase'
+                     VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
                    end
           end
-          append_pull(opts, OPT_PULL + OPT_FETCH - (FOR_FETCH + FNO_FETCH), NO_PULL + NO_FETCH, remote: remote,
-                                                                                                flag: flag)
+          append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
+                      no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
           source(sync: sync, sub: if verbose
                                     [
                                       { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: :red, index: 4 },
@@ -461,39 +584,44 @@ module Squared
                                   end, **threadargs)
         end
 
-        def rebase(flag = nil, sync: invoked_sync?('rebase', flag), command: nil, commit: nil, upstream: nil,
-                   branch: nil)
+        def rebase(flag = nil, opts = [], sync: invoked_sync?('rebase', flag), commit: nil, upstream: nil, branch: nil,
+                   command: nil)
           return pull(:rebase, sync: sync) unless flag
 
           cmd = git_session 'rebase'
-          cmd << '--interactive' unless flag == :send || !option('interactive', 'i')
           case flag
+          when :branch
+            branch = option_sanitize(opts, OPT_GIT[:rebase], no: OPT_GIT[:no][:rebase]).first
+            case branch.size
+            when 0
+              append_head
+            when 1, 2
+              append_value(branch, delim: true)
+            else
+              append_value([branch.pop, branch.pop].reverse, delim: true)
+              option_clear branch
+            end
           when :onto
             return unless upstream
 
-            cmd << shell_option('onto', commit)
+            cmd << '--interactive' if option('interactive', 'i')
+            cmd << shell_option('onto', commit) if commit
             cmd << shell_escape(upstream)
             append_head branch
-          when :root
-            return unless branch
-
-            cmd << shell_option('onto', commit) if commit
-            cmd << '--root' << shell_escape(branch)
-          when :send
-            return unless OPT_REBASE.include?(command)
+          else
+            return unless VAL_GIT[:rebase][:send].include?(command)
 
             cmd << "--#{command}"
-          else
-            return
           end
           source
         end
 
-        def fetch(flag = nil, sync: invoked_sync?('fetch', flag), remote: nil, opts: [])
+        def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
           cmd = git_session 'fetch'
           cmd << '--all' if !remote && !opts.include?('multiple') && option('all')
           cmd << '--verbose' if verbose && !opts.include?('quiet')
-          append_pull(opts, OPT_FETCH, NO_FETCH + FNO_FETCH, remote: remote, flag: flag)
+          append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]),
+                                                           remote: remote, flag: flag)
           source(sync: sync, **threadargs)
         end
 
@@ -514,36 +642,39 @@ module Squared
           opts[:local] = val != '0' if (val = option('local', strict: true))
           opts.delete(:'recurse-submodules') || opts.delete(:'no-recurse-submodules') if append_submodules(:clone)
           append_hash opts
-          if cmd.include?('--quiet') || cmd.include?('-q')
-            quiet = true
-          elsif verbose
-            quiet = false
-          else
-            cmd << '--quiet'
-            quiet = true
-          end
-          append_value([data[0], path], delim: true, escape: false)
-          source(banner: sync && !quiet, multiple: !sync || quiet)
+          cmd << '--quiet' unless verbose
+          append_value(data[0], path, delim: true)
+          source(banner: sync && !quiet?, multiple: !sync || quiet?)
         end
 
-        def stash(flag = nil, files = [], sync: invoked_sync?('stash', flag), commit: nil)
-          cmd = git_session 'stash', flag || 'push'
-          case flag
-          when :apply, :pop
-            cmd << '--index' if option('index')
-            cmd << commit
+        def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
+          if flag
+            cmd = git_session 'stash', flag
+            list = OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])
+            refs = option_sanitize(opts, list).first
+            case flag
+            when :push
+              append_pathspec refs
+            when :pop, :apply, :drop
+              cmd << shell_quote(refs.pop)
+              option_clear refs
+            when :list
+              out, banner, from = source(io: true)
+              print_item banner
+              ret = write_lines(out)
+              list_result(ret, 'objects', from: from)
+              return
+            end
           else
-            append_option %w[all staged include-untracked].freeze
+            git_session 'stash', 'push'
+            append_option(%w[all keep-index include-untracked staged].freeze, no: true, ignore: false)
             append_message option('message', 'm', ignore: false)
-            append_pathspec files
           end
-          source(sync: sync, **threadargs)
+          source(banner: !quiet?, sync: sync, **threadargs)
         end
 
         def status(*, sync: invoked_sync?('status'), **)
-          cmd = git_session 'status'
-          cmd << (option('long') ? '--long' : '--short')
-          cmd << '--branch' if option('branch')
+          cmd = git_session 'status', option('long') ? '--long' : '--short'
           if (val = option('ignore-submodules', ignore: false))
             cmd << basic_option('ignore-submodules', case val
                                                      when '0', 'none'
@@ -564,8 +695,8 @@ module Squared
           end
           ret = write_lines(out, banner: banner, sub: if verbose
                                                         [
-                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: :red, index: 2 },
-                                                          { pat: /^([A-Z?!])(.+)$/, styles: :green },
+                                                          { pat: /^(.)([A-Z])(.+)$/, styles: :red, index: 2 },
+                                                          { pat: /^([A-Z])(.+)$/, styles: :green },
                                                           { pat: /^(\?\?)(.+)$/, styles: :red },
                                                           { pat: /^(## )(.+)(\.{3})(.+)$/,
                                                             styles: [nil, :green, nil, :red], index: -1 }
@@ -574,34 +705,41 @@ module Squared
           list_result(ret, 'files', from: from, action: 'modified')
         end
 
-        def reset(flag, files = nil, mode: nil, ref: nil)
+        def reset(flag, opts = [], refs: nil, ref: nil, mode: nil, commit: nil)
           cmd = git_session 'reset'
           case flag
+          when :commit, :index
+            out = option_sanitize(opts, OPT_GIT[:reset] + VAL_GIT[:reset], no: OPT_GIT[:no][:reset]).first
+            if flag == :commit
+              append_value(commit, delim: true)
+              option_clear out
+              ref = false
+            else
+              (refs ||= []).concat(out)
+            end
           when :mode
-            case mode
-            when 'mixed'
-              cmd << '--mixed'
+            return unless VAL_GIT[:reset].include?(mode)
+
+            cmd << "--#{mode}"
+            if mode == 'mixed'
               cmd << '-N' if option('n')
               cmd << '--no-refresh' if option('refresh', equals: '0')
-            when 'soft', 'hard', 'merge', 'keep'
-              cmd << "--#{mode}"
-            when 'submodules'
-              cmd << '--recurse-submodules'
-            when 'no-submodules'
-              cmd << '--no-recurse-submodules'
-            else
-              return
             end
           when :patch
             cmd << '--patch'
+          else
+            return
+          end
+          unless ref == false
+            append_commit ref
+            append_pathspec refs if refs
           end
-          append_commit ref
-          append_pathspec files if files
           source
         end
 
-        def checkout(flag, files = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil)
+        def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil)
           cmd = git_session 'checkout'
+          append_option 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
@@ -624,92 +762,122 @@ module Squared
             end
             cmd << '--track' << origin
           when :detach
-            cmd << "--#{flag}" << commit
+            cmd << '--detach' << commit
           else
-            cmd << "--#{flag}"
-            append_first %w[ours theirs]
-            append_head
-            append_pathspec files
+            out = option_sanitize(opts, OPT_GIT[:checkout], no: OPT_GIT[:no][:checkout]).first
+            if flag == :commit
+              append_value(commit, delim: true)
+              option_clear out
+            else
+              append_head
+              append_pathspec out
+            end
           end
           source
         end
 
-        def tag(flag, refs, message: nil, commit: nil)
+        def tag(flag, opts = [], refs: [], message: nil, commit: nil)
           cmd = git_session 'tag'
           case flag
           when :add
             if option('sign')
               cmd << '--sign'
-            else
-              out = cmd.to_s
-              cmd << '--annotate' if %w[-s --sign -u --local-user].none? { |val| out.include?(" #{val}") }
+            elsif !session_arg?('s', 'sign', 'u', 'local-user')
+              cmd << '--annotate'
             end
             if !commit && message && (hash = commithash(message))
               commit = hash
             else
               append_message message
             end
-            append_value(refs, escape: false)
+            append_value refs
             append_head commit
-          when :delete, :list, :merged
+          when :list
+            cmd << '--list'
+            grep = option_sanitize(opts, OPT_GIT[:tag], no: OPT_GIT[:no][:tag]).first
+            out, banner, from = source(io: true)
+            print_item banner
+            ret = write_lines(out, grep: grep)
+            list_result(ret, 'tags', from: from, grep: grep)
+            return
+          when :delete
+            cmd << '--delete'
+            append_value refs
+          else
             cmd << shell_option(flag, commit)
-            append_option(%w[contains sort] + (flag == :list ? ['merged'] : []), equals: true) unless flag == :delete
-            append_value(refs, escape: false)
           end
           source
         end
 
-        def diff(flag, files = [], branch: nil, index: 0, range: [])
+        def logx(flag, opts = [], range: [])
+          cmd = git_session 'log'
+          files = option_sanitize(opts, collect_hash(OPT_GIT[:log]), no: collect_hash(OPT_GIT[:no][:log])).first
+          case flag
+          when :between, :contain
+            cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
+          else
+            commit, files = files.partition do |val|
+              val.start_with?('^') || (!%r{^[.\\/]}.match?(val) && !%r{[\\/]$}.match?(val)) || commithash(val)
+            end
+            cmd.merge(commit.map { |val| commithash(val) || shell_quote(val) }) unless commit.empty?
+          end
+          append_nocolor
+          append_pathspec files
+          source(exception: false)
+        end
+
+        def diff(flag, opts = [], refs: [], branch: nil, range: [])
           cmd = git_session 'diff'
-          sha = []
+          files = option_sanitize(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff],
+                                  no: OPT_GIT[:no][:log][:diff]).first
           case flag
-          when :files, :between, :contain
+          when :files, :view, :between, :contain
             cmd.delete('--cached')
           else
             items = files.dup
+            sha = nil
             files.clear
             items.each do |val|
-              if (hash = commithash(val))
-                sha << hash
+              if (s = commithash(val))
+                (sha ||= []).push(s)
               else
                 files << val
               end
             end
           end
-          if (val = option('unified')).to_i > 0
-            cmd << basic_option('unified', val)
-          end
           append_nocolor
-          case flag
-          when :cached
-            cmd << '--cached'
-            cmd << '--merge-base' if option('merge-base')
-          when :branch
-            cmd << branch
-          when :files
+          if flag == :files
             cmd << '--no-index'
-          when :between, :contain
-            cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
+            append_pathspec(refs, parent: true)
           else
-            if (val = option('index')) || index > 0
-              cmd << "HEAD~#{val || index}"
-            elsif !sha.empty? && option('merge-base')
-              cmd << '--merge-base'
-            end
-          end
-          unless sha.empty?
-            if cmd.include?('--cached')
-              raise_error('diff', sha.join(', '), hint: 'one commit') if sha.size > 1
-              cmd << sha.first
+            case flag
+            when :view
+              cmd << '--merge-base' if option('merge-base')
+              cmd << shell_quote(range.first, quote: true) << shell_quote(range.last, quote: true)
+            when :between, :contain
+              cmd.delete('--merge-base')
+              cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
             else
-              cmd.merge(sha)
+              cmd << '--cached' if flag == :cached
+              cmd << '--merge-base' if option('merge-base')
+              cmd << shell_quote(branch) if branch
+              if sha
+                if session_arg?('cached')
+                  raise_error('diff', sha.join(', '), hint: 'one commit') if sha.size > 1
+                  cmd << sha.first
+                else
+                  cmd.merge(sha)
+                end
+              elsif (n = option('index'))
+                cmd << "HEAD~#{n}"
+              end
             end
+            append_pathspec files
           end
-          append_pathspec(files, parent: flag == :files)
-          source(exception: cmd.include?('--exit-code'))
+          source(exception: session_arg?('exit-code'))
         end
 
-        def commit(flag, files = [], message: nil, pass: false)
+        def commit(flag, *, refs: [], message: nil, pass: false)
           message ||= option('message', 'm', prefix: 'git', ignore: false)
           amend = flag.to_s.start_with?('amend')
           if !message && !amend
@@ -717,45 +885,59 @@ module Squared
 
             raise_error('commit', 'GIT_MESSAGE="description"', hint: 'missing')
           end
-          pathspec = if flag == :all || (amend && files.size == 1 && files.first == '*')
+          pathspec = if flag == :all || (amend && refs.size == 1 && refs.first == '*')
                        '--all'
+                     elsif (refs = projectmap(refs)).empty?
+                       raise_error('commit', 'pathspec', hint: 'missing')
                      else
-                       raise_error('commit', 'pathspec', hint: 'missing') if (files = projectmap(files)).empty?
-                       "-- #{files.join(' ')}"
+                       "-- #{refs.join(' ')}"
                      end
-          format = '%(if)%(HEAD)%(then)%(refname:short)...%(upstream:short)...%(upstream:track)%(end)'
-          branch = nil
           origin = nil
-          source(git_output('fetch --no-tags --quiet'), io: true, banner: false, stdout: true)
-          cmd = git_output("for-each-ref --format=\"#{format}\" refs/heads")
-          source(cmd, io: true, banner: false).first.each do |line|
-            next if (line = line.chomp).empty?
-
-            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?
-              return nil if pass
-
-              raise_error('no remote upstream', hint: branch)
+          branch = nil
+          upstream = nil
+          source(git_output('fetch', '--no-tags', '--quiet'), io: true, banner: false)
+          source(git_output('branch', '-vv', '--list'), io: true, banner: false).first.each do |val|
+            next unless (data = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
+
+            branch = data[1]
+            if !data[3]
+              unless (origin = option('repository', prefix: 'git', ignore: false))
+                out = source(git_output('log', '-n1', '--format=%h%d'), io: true, stdout: true, banner: false).first
+                if out =~ /^#{data[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
+                  split_escape($1).each do |val|
+                    next unless val.end_with?("/#{branch}")
+
+                    origin = val[0, val.size - branch.size - 1]
+                    break
+                  end
+                end
+              end
+              upstream = true if origin
+            elsif data[3] =~ %r{^(.+)/#{Regexp.escape(branch)}$}
+              origin = $1
             end
             break
           end
-          i = origin.index('/')
-          branch = "#{branch}:#{origin[i + 1..-1]}" unless origin.end_with?("/#{branch}")
-          origin = origin[0..i - 1]
+          raise_error('commit', 'work tree is not usable') unless origin && branch
           cmd = git_session('commit', option('dry-run') && '--dry-run', options: false)
-          cmd << '--amend' if amend
+          if amend
+            cmd << '--amend'
+          else
+            cmd.delete('--amend')
+          end
           if message
             append_message message
           elsif flag == :'amend-orig' || option('no-edit')
             cmd << '--no-edit'
           end
           a = git_output 'add', '--verbose'
-          b = git_output 'push'
-          b << '--dry-run' if dryrun?
+          b = git_output 'push', upstream && '--set-upstream'
+          if dryrun?
+            a << '--dry-run'
+            b << '--dry-run'
+          end
           a << pathspec
-          b << '--force-with-lease' if amend
+          b << '--force' if amend
           b << origin << branch
           puts if pass
           source a
@@ -763,7 +945,7 @@ module Squared
           source b
         end
 
-        def branch(flag, names = [], target: nil, ref: nil, opts: [])
+        def branch(flag, opts = [], refs: [], ref: nil, target: nil)
           cmd = git_session 'branch'
           stdout = false
           case flag
@@ -780,8 +962,10 @@ module Squared
             end
             cmd << '--force' if option('force')
           when :set
-            if ref.start_with?('!')
-              cmd << '--unset-upstream' << shell_escape(ref[1..-1])
+            return unless ref
+
+            if ref.start_with?('^')
+              cmd << '--unset-upstream' << shell_escape(arg[1..-1])
               target = nil
               stdout = true
             else
@@ -789,9 +973,9 @@ module Squared
             end
             ref = nil
           when :delete
-            force, list = names.partition { |val| val =~ /^[\^~]/ }
+            force, list = refs.partition { |val| val =~ /^[\^~]/ }
             force.each do |val|
-              dr = val[0..2]
+              dr = val[0, 3]
               d = dr.include?('^') ? '-D' : '-d'
               r = dr.include?('~') ? '-r' : nil
               source git_output('branch', d, r, shell_quote(val.sub(/^[\^~]+/, '')))
@@ -803,27 +987,18 @@ module Squared
           when :move, :copy
             flag = "-#{flag.to_s[0]}"
             cmd << (option('force') ? flag.upcase : flag)
-            names.compact.each { |val| cmd << shell_quote(val) }
+            refs.compact.each { |val| cmd << shell_quote(val) }
             stdout = true
           when :edit
             cmd << '--edit-description'
           when :current
             cmd << '--show-current'
           else
-            opts, pat = option_partition(opts, OPT_BRANCH, no: NO_BRANCH)
+            opts = option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch]).first
             grep = []
             opts.each do |opt|
               if opt =~ /^(v+)$/
                 cmd << "-#{$1}"
-              elsif opt =~ pat
-                case $1
-                when 'column', 'format'
-                  cmd << quote_option($1, $2)
-                when 'abbrev'
-                  cmd << basic_option($1, $2) if $2.to_i > 0
-                else
-                  cmd << shell_option($1, $2)
-                end
               else
                 grep << opt
               end
@@ -844,16 +1019,24 @@ module Squared
           source(stdout: stdout)
         end
 
-        def restore(flag, files, tree: nil)
-          source = flag == :source
-          cmd = git_session 'restore', source && files.empty? ? '--patch' : nil, shell_option(flag, tree)
-          append_option %w[staged worktree]
-          append_first %w[ours theirs]
-          append_pathspec(files, expect: !cmd.include?('--patch'))
-          source(stdout: !source)
+        def restore(flag, opts = [], tree: nil)
+          cmd = git_session 'restore'
+          refs = option_sanitize(opts, OPT_GIT[:restore], no: OPT_GIT[:no][:restore]).first
+          if flag == :source
+            cmd << '--patch' if refs.empty?
+            cmd << shell_option('source', tree)
+          else
+            cmd << "--#{flag}"
+          end
+          if session_arg?('p', 'patch')
+            option_clear refs
+          else
+            append_pathspec(refs, expect: true)
+          end
+          source(sync: false, stderr: true)
         end
 
-        def show(objs, format: nil, opts: nil)
+        def show(format, opts = [])
           cmd = git_session 'show'
           if format
             case (val = format.downcase)
@@ -863,41 +1046,54 @@ module Squared
               if format =~ /^t?format:/ || format.include?('%')
                 cmd << quote_option('pretty', format)
               else
-                objs << format
+                opts << format
               end
             end
           end
-          if opts
-            append_hash opts
-            banner = format != 'oneline'
-          else
+          refs = option_sanitize(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff],
+                                 no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log], pass: [:base])).first
+          unless val == 'oneline' && session_arg?('abbrev-commit')
             cmd << basic_option('abbrev', val) if (val = option('abbrev')) && val.to_i > 0
             banner = true
           end
-          append_value(objs, delim: true)
+          append_value(refs, delim: true)
           source(exception: false, banner: banner)
         end
 
-        def rev_parse(flag, ref: nil, size: nil)
-          git_session 'rev-parse', if flag == :branch
-                                     '--abbrev-ref'
-                                   else
-                                     (n = size.to_i) > 0 ? basic_option('short', [n, 5].max) : '--verify'
-                                   end
-          append_commit ref
-          source
+        def rev_parse(flag, opts = [], ref: nil, size: nil)
+          cmd = git_session 'rev-parse', if flag == :parseopt
+                                           '--parseopt'
+                                         elsif opts.delete('sq-quote')
+                                           '--sq-quote'
+                                         end
+          case flag
+          when :commit
+            cmd << ((n = size.to_i) > 0 ? basic_option('short', [n, 5].max) : '--verify')
+            append_commit ref
+          when :branch
+            cmd << '--abbrev-ref'
+            append_commit ref
+          else
+            args = option_sanitize(opts, OPT_GIT[:rev_parse][flag]).first
+            append_value(args, escape: session_arg?('sq-quote'))
+          end
+          source(banner: verbose == 1)
         end
 
-        def ls_remote(flag, grep: nil)
-          git_session 'ls-remote', "--#{flag}", '--refs'
+        def ls_remote(flag, opts = [], remote: nil)
+          cmd = git_session 'ls-remote', '--refs'
+          cmd << "--#{flag}" unless flag == :remote
+          grep = option_sanitize(opts, OPT_GIT[:ls_remote]).first
+          cmd << shell_quote(remote) if remote
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: grep)
           list_result(ret, flag.to_s, from: from, grep: grep)
         end
 
-        def ls_files(flag, grep: nil)
+        def ls_files(flag, opts = [])
           git_session 'ls-files', "--#{flag}"
+          grep = option_sanitize(opts, OPT_GIT[:ls_files]).first
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: grep)
@@ -924,8 +1120,8 @@ module Squared
             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 if from
+          log.info cmd
+          on :first, from
           banner = if banner
                      format_banner((banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), ''), banner: true)
                    end
@@ -960,26 +1156,32 @@ module Squared
               end
             end
           rescue StandardError => e
-            log&.error e
-            ret = on(:error, from, e) if from
+            log.error e
+            ret = on(:error, from, e)
             raise if exception && ret != true
 
             warn log_message(Logger::WARN, e) if warning?
           else
-            on :last, from if from
+            on :last, from
           end
         end
 
         def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
-          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(String)
+          grep = if grep && !grep.empty?
+                   as_a(grep).map do |val|
+                     next val if val.is_a?(Regexp)
+
+                     Regexp.new(val == '*' ? '.+' : val.to_s)
+                   end
+                 end
           sub = nil if stdin?
           ret = 0
           out = []
           data.each do |line|
-            next if grep && !line.match?(grep)
+            next if grep&.none? { |pat| pat.match?(line) }
 
             if loglevel
-              log&.add loglevel, line
+              log.add loglevel, line
             else
               sub&.each { |h| line = sub_style(line, **h) }
               if banner
@@ -999,38 +1201,37 @@ module Squared
             if size > 0
               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}",
+              puts print_footer("#{size} #{size == 1 ? type.sub(/s\z/, '') : type}",
                                 sub: { pat: /\A(\d+)(.+)\z/, styles: styles })
             else
-              puts empty_status("No #{type} were #{action}", 'grep', grep)
+              puts empty_status("No #{type} were #{action}", 'grep', grep.is_a?(Array) ? case grep.size
+                                                                                         when 0
+                                                                                           nil
+                                                                                         else
+                                                                                           grep.join(', ')
+                                                                                         end : grep.to_s)
             end
           end
-          on :last, from if from
+          on :last, from
         end
 
-        def append_pull(opts, list, no = [], target: @session, flag: nil, remote: nil)
-          target << '--force' if option('force', target: target)
-          modules = append_submodules(target: target)
+        def append_pull(opts, list, target: @session, no: nil, flag: nil, remote: nil)
+          cmd << '--force' if option('force')
+          rsm = append_submodules(target: target)
           out = []
           refspec = []
-          opts, pat = option_partition(opts, remote ? list + ['refspec=s'] : list, target: target, no: no)
+          opts, pat = option_sanitize(opts, remote ? list + ['refspec=s'] : list, target: target, no: no)
           opts.each do |opt|
             if opt =~ pat
               case $1
               when 'rebase'
-                target << basic_option($1, $2) if VAL_REBASE.include?($2)
+                target << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
               when 'shallow-since'
                 next unless (val = Date.parse($2))
 
                 target << quote_option($1, val.strftime('%F %T'))
               when 'recurse-submodules'
-                target << basic_option($1, $2) unless modules
-              when 'shallow-exclude', 'gpg-sign', 'signoff', 'strategy', 'strategy-option'
-                target << shell_option($1, $2)
-              when 'refmap', 'negotiation-tip'
-                target << quote_option($1, $2)
-              when 'depth', 'deepen', 'log', 'jobs'
-                target << basic_option($1, $2) if $2.to_i > 0
+                target << basic_option($1, $2) unless rsm
               when 'refspec'
                 refspec << shell_escape($2, quote: true)
               end
@@ -1039,9 +1240,9 @@ module Squared
             end
           end
           if remote
-            append_value(remote, target: target, delim: true, quote: true)
-            if (val = option('refspec', target: target, strict: true))
-              append_value(split_escape(val), target: target, escape: false)
+            append_value(remote, target: target, delim: true)
+            if (val = option('refspec', strict: true))
+              append_value(split_escape(val), target: target)
             else
               target.merge(refspec)
             end
@@ -1059,47 +1260,45 @@ module Squared
         end
 
         def append_pathspec(files = [], target: @session, expect: false, parent: false)
-          if files.empty? && (val = option('pathspec', target: target))
-            files = split_escape(val)
-          end
-          files = projectmap(files, parent: parent)
-          if !files.empty?
-            target << "-- #{files.join(' ')}"
-          elsif expect
-            raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
+          if session_arg?('pathspec-from-file')
+            option_clear files
+          else
+            if files.empty? && (val = option('pathspec'))
+              files = split_escape(val)
+            end
+            files = projectmap(files, parent: parent)
+            if !files.empty?
+              target << "-- #{files.join(' ')}"
+            elsif expect
+              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
+            end
           end
         end
 
         def append_message(val, target: @session)
-          target << "--message=\"#{double_quote(val)}\"" unless val.to_s.empty?
+          target << quote_option('message', val) unless val.to_s.empty?
         end
 
         def append_head(val = nil, target: @session)
           return target << val if val
 
-          append_first(%w[head tree-ish object], target: target, flag: false, ignore: false)
+          append_first('head', 'tree-ish', 'object', target: target, flag: false, ignore: false)
         end
 
         def append_submodules(from = nil, target: @session)
-          return unless (val = option('recurse-submodules', target: target, ignore: false))
+          return unless (val = option('recurse-submodules', 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)
-              end
+            projectmap(split_escape(val)).each do |path|
+              target << basic_option('recurse-submodules', path)
             end
+            target
           else
             target << case val
                       when 'no', '0'
                         '--no-recurse-submodules'
                       when 'yes', 'on-demand'
-                        "--recurse-submodules=#{val}"
+                        "--recurse-submodules#{from == :reset ? '' : "=#{val}"}"
                       else
                         '--recurse-submodules'
                       end
@@ -1115,8 +1314,14 @@ module Squared
           git_session(*cmd, main: false, options: false, **kwargs)
         end
 
-        def dryrun?(*)
-          !!@session&.include?('--dry-run')
+        def dryrun?(*, target: @session, **)
+          !!target&.include?('--dry-run')
+        end
+
+        def quiet?(target: @session)
+          return false unless target
+
+          target.include?('--quiet') || (target.include?('-q') && target.first == 'git')
         end
 
         def gitpath
@@ -1124,7 +1329,7 @@ module Squared
         end
 
         def commithash(val)
-          (data = /\A#\{(\h{5,40})\}\z/.match(val)) ? data[1] : nil
+          val =~ /\A#\{(\h{5,40})\}\z/ ? $1 : nil
         end
 
         def threadargs