squared 0.5.26 → 0.6.0

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

@@ -41,13 +41,13 @@ module Squared
           end
         end
         data.each do |key, val|
-          if val.is_a?(Hash)
-            uri = val.fetch(:uri, '')
-            opts = val.fetch(:options, {})
-          else
-            uri = val.is_a?(String) ? val : key.to_s
-            opts = options
-          end
+          uri = if val.is_a?(Hash)
+                  opts = val.fetch(:options, {})
+                  val.fetch(:uri, '')
+                else
+                  opts = options
+                  val.is_a?(String) ? val : key.to_s
+                end
           unless uri.match?(GIT_PROTO) || Pathname.new(uri).absolute?
             if uri.start_with?('.')
               uri = @root + uri
@@ -57,8 +57,7 @@ module Squared
               next
             end
           end
-          key = task_name key
-          GIT_REPO[main][key] = [uri.to_s, opts]
+          GIT_REPO[main][key = task_name(key)] = [uri.to_s, opts]
           @kind[key] << Project::Git
         end
         if cache == true
@@ -69,6 +68,16 @@ module Squared
         self
       end
 
+      def git_repo(name)
+        (ret = GIT_REPO[main]) && ret[name]
+      end
+
+      def git_clone?(path, name = nil)
+        return false if name && !git_repo(name)
+
+        !path.exist? || path.empty?
+      end
+
       def revbuild(file: nil)
         @revfile = @home.join(file || "#{@main}.revb")
         @revdoc = JSON.parse(@revfile.read) if @revfile.exist?
@@ -81,10 +90,6 @@ module Squared
         self
       end
 
-      def git_repo(name)
-        (ret = GIT_REPO[main]) && ret[name]
-      end
-
       def rev_entry(*keys, val: nil, create: true)
         return unless @revdoc
         return @revdoc.dig(*keys) unless val
@@ -133,22 +138,11 @@ module Squared
         end
         File.write(@revfile, JSON.pretty_generate(@revdoc))
       rescue StandardError => e
-        warn log_message(Logger::WARN, e, pass: true) if warning
+        log&.debug e
+        warn log_message(Logger::WARN, e, pass: true) if warning?
       ensure
         @revlock = false
       end
-
-      def git_clone?(path, name = nil)
-        return false if name && !git_repo(name)
-
-        !path.exist? || path.empty?
-      end
-
-      private
-
-      def rev_timenow
-        Time.now.utc.strftime('%s%L').to_i
-      end
     end
     Application.include Git
 
@@ -158,12 +152,11 @@ module Squared
           common: %w[c=q bare glob-pathspecs icase-pathspecs literal-pathspecs no-optional-locks no-pager
                      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 omit-empty 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,
+          add: %w[A e|edit f|force ignore-errors ignore-missing i|interactive n|dry-run p|patch pathspec-file-nul
+                  refresh renormalize sparse u|update v|verbose chmod=b pathspec-from-file=p].freeze,
+          branch: %w[a|all create-reflog i|ignore-case omit-empty 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,
           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: {
@@ -173,17 +166,22 @@ module Squared
           fetch: {
             base: %w[multiple porcelain progress P|prune-tags refetch stdin u|update-head-ok
                      recurse-submodules-default=b].freeze,
-            pull: %w[n t 4|ipv4 6|ipv6 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
-                     upload-pack=q].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 upload-pack=q].freeze
           }.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,
+                      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,
+            grep: %w[e f=p h H I O=bm r all-match and G|basic-regexp break cached column c|count E|extended-regexp
+                     l|files-with-matches L|files-without-match F|fixed-strings full-name W|function-context heading
+                     i|ignore-case v|invert-match n|line-number name-only no-index not z|null o|only-matching or
+                     P|perl-regexp q|quiet recurse-submodules p|show-function a|text untracked w|word-regexp
+                     A|after-context=i B|before-context=i color=b C|context=i m|max-count=n max-depth=i
+                     open-files-in-pager=b threads=n].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
                        s|signoff strategy=b X|strategy-option=b].freeze,
@@ -203,26 +201,27 @@ module Squared
             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
+            diff: %w[p R u z B=bm? C=bm? l=im G=qm I=qm M=bm? O=qm S=qm 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 break-rewrites=b? color=b color-moved=b color-moved-ws=b color-words=q?
-                     diff-algorithm=b diff-filter=q? X|dirstat=b? dirstat-by-file=b? dst-prefix=q find-copies=i?
-                     find-object=b find-renames=b? 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=b? stat-count=i stat-width=i stat-name-width=i
-                     submodule=b? unified=i word-diff=b? word-diff-regex=q ws-error-highlight=b].freeze
+                     diff-algorithm=b diff-filter=e? X|dirstat=b? dirstat-by-file=b? dst-prefix=q find-copies=i?
+                     find-object=b find-renames=b? ignore-matching-lines=q ignore-submodules=b? 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=b? stat-count=i stat-width=i stat-name-width=i submodule=b?
+                     word-diff=b? word-diff-regex=q ws-error-highlight=b].freeze,
+            diff_context: %w[U=im inter-hunk-context=i unified=i].freeze
           }.freeze,
           ls_files: %w[f t v z debug deduplicate directory eol error-unmatch exclude-standard full-name i|ignored
                        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 symref o|server-option=q sort=q upload-pack=q].freeze,
-          merge: %w[e n S=bm? allow-unrelated-histories ff-only m=q q|quiet v|verbose cleanup=b F|file=p gpg-sign=b?
-                    into-name=b log=i s|strategy=b X|strategy-option=b].freeze,
-          pull: %w[e n S=bm? allow-unrelated-histories ff-only cleanup=b gpg-sign=b? log=i r|rebase=v? s|strategy=b
-                   X|strategy-option=b].freeze,
+          merge: %w[e n S=bm? allow-unrelated-histories compact-summary ff-only m=q q|quiet v|verbose cleanup=b F|file=p
+                    gpg-sign=b? into-name=b log=i s|strategy=b X|strategy-option=b].freeze,
+          pull: %w[e n S=bm? allow-unrelated-histories compact-summary ff-only cleanup=b gpg-sign=b? log=i r|rebase=v?
+                   s|strategy=b X|strategy-option=b].freeze,
           rebase: %w[n C=im S=bm? allow-empty-message apply committer-date-is-author-date edit-todo empty=b
                      f|force-rebase ignore-date ignore-whitespace i|interactive keep-base m|merge no-ff q|quiet quit
                      reset-author-date root show-current-patch signoff v|verbose empty=b x|exec=q gpg-sign=b? onto=b
@@ -241,8 +240,8 @@ module Squared
                    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
-                     p|patch S|staged m|message=q pathspec-from-file=p].freeze,
+            push: %w[a|all u|include-untracked k|keep-index no-keep-index no-include-untracked pathspec-file-nul p|patch
+                     S|staged m|message=q pathspec-from-file=p].freeze,
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
@@ -260,13 +259,15 @@ module Squared
           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: {
+            add: %w[all ignore-removal].freeze,
             blame: %w[progress].freeze,
             branch: %w[color color-moved column track].freeze,
             checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
             fetch: {
               base: %w[auto-gc auto-maintenance write-commit-graph write-fetch-head].freeze,
-              pull: %w[all recurse-submodules show-forced-updates tags].freeze
+              pull: %w[all ipv4 ipv6 recurse-submodules show-forced-updates tags].freeze
             },
+            grep: %w[color exclude-standard recursive textconv].freeze,
             log: {
               base: %w[decorate mailmap merges use-mailmap].freeze,
               diff: %w[color color-moved ext-diff indent-heuristic patch relative rename-empty textconv].freeze,
@@ -302,33 +303,6 @@ module Squared
         class << self
           include Rake::DSL
 
-          def populate(ws, **)
-            return if ws.series.exclude?(:pull, true) || ws.size == 1
-
-            namespace ws.task_name('git') do |ns|
-              ws.format_desc(all = ws.task_join(ns.scope.path, 'all'), 'stash|rebase|autostash?,depend?')
-              task 'all' do |_, args|
-                args = args.to_a
-                cmd = if args.include?('stash')
-                        ['stash', 'pull']
-                      elsif args.include?('rebase')
-                        ['rebase']
-                      elsif args.include?('autostash')
-                        ['autostash']
-                      else
-                        ['pull']
-                      end
-                cmd.map! { |val| ws.task_sync(val) }
-                cmd << ws.task_sync('depend') if args.include?('depend') && !ws.series.exclude?(:depend, true)
-                cmd << ws.task_sync('build')
-                Common::Utils.task_invoke(*cmd, **ws.invokeargs)
-              end
-
-              ws.series.sync << all
-              ws.series.multiple << all
-            end
-          end
-
           def tasks
             %i[pull rebase autostash fetch clone stash status branch revbuild].freeze
           end
@@ -341,13 +315,13 @@ module Squared
         end
 
         subtasks({
-          'branch' => %i[create track delete move copy list all current].freeze,
+          'branch' => %i[create track delete move copy list current].freeze,
           '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,
           'files' => %i[cached modified deleted others].freeze,
-          'git' => %i[add blame clean mv revert rm status].freeze,
+          'git' => %i[add blame clean grep mv revert rm status].freeze,
           'log' => %i[view between contain].freeze,
           'merge' => %i[commit no-commit send].freeze,
           'pull' => %i[origin remote all].freeze,
@@ -357,7 +331,7 @@ module Squared
           '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 all].freeze,
+          'stash' => %i[push pop apply branch drop clear list all staged worktree].freeze,
           'submodule' => %i[status update branch url sync].freeze,
           'switch' => %i[branch create detach].freeze,
           'tag' => %i[add sign delete list].freeze
@@ -365,7 +339,7 @@ module Squared
 
         def initialize(*, **)
           super
-          @submodule = basepath('.gitmodules').exist?
+          @submodule = exist?('.gitmodules')
           initialize_ref Git.ref if gitpath.exist?
         end
 
@@ -388,16 +362,16 @@ module Squared
                     if flag == :remote
                       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
-                        end
+                        args = if (remote = args.remote)
+                                 args.extras
+                               else
+                                 remote = choice_remote
+                                 args.to_a
+                               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*', after: ('pattern*' if flag == :all && action == 'pull'))
                       task flag do |_, args|
                         __send__ action, flag, args.to_a
                       end
@@ -434,11 +408,11 @@ module Squared
                         commit(flag, message: args.message)
                       end
                     else
-                      format_desc(action, flag, 'pathspec+', before: flag == :add ? 'opts*' : nil)
+                      format_desc(action, flag, 'pathspec+', before: ('opts*' if flag == :add))
                       task flag do |_, args|
                         if flag == :fixup
-                          ref, squash, pick = choice_commit(accept: [['Auto squash?', true]], reflog: false,
-                                                            values: ['Pick [amend|reword]'])
+                          ref, squash, pick = choice_commit(reflog: false, accept: [accept_b('Auto squash?')],
+                                                            values: 'Pick [amend|reword]')
                           pick &&= case pick.downcase
                                    when 'a', 'amend'
                                      'amend'
@@ -480,7 +454,7 @@ module Squared
                       task flag do |_, args|
                         refs = args.to_a
                         if refs.empty?
-                          refs = choice_refs('Choose a tag', 'tags', multiple: true, accept: 'Delete?', series: true)
+                          refs = choice_refs('Choose a tag', 'tags', multiple: true, series: true, accept: 'Delete?')
                           remote = choice_remote
                         end
                         tag(flag, refs: refs, remote: remote)
@@ -493,12 +467,13 @@ module Squared
                           commit = commithead args.commit
                           remote = args.remote
                         else
-                          commit, name, message = choice_commit(values: [['Enter tag name', true], 'Enter message'],
-                                                                series: true, reflog: false)
+                          commit, name, message = choice_commit(reflog: false, series: true,
+                                                                values: [['Enter tag name', true], 'Enter message'])
                           remote = choice_remote
                         end
-                        ret = tag(flag, refs: [name], message: message, commit: commit, remote: remote)
-                        print_success if success?(ret, !remote)
+                        tag(flag, refs: [name], message: message, commit: commit, remote: remote).tap do |ret|
+                          success?(ret, !remote)
+                        end
                       end
                     end
                   when 'stash'
@@ -514,9 +489,8 @@ module Squared
                   when 'log', 'diff'
                     case flag
                     when :view, :between, :contain
-                      view = flag == :view
-                      if view && action == 'log'
-                        format_desc action, flag, '(^)commit*|:,opts*,ref?,pathspec*'
+                      if action == 'log' && flag == :view
+                        format_desc action, flag, '(^)commit*|:,opts*,pathspec*'
                         task flag do |_, args|
                           args = args.to_a
                           if args.first == ':'
@@ -543,16 +517,17 @@ module Squared
                         format_desc action, flag, 'commit1,commit2,opts*,pathspec*'
                         task flag, [:commit1, :commit2] do |_, args|
                           commit1 = commithead args.commit1
-                          if commit1
-                            commit2 = commithead param_guard(action, flag, args: args, key: :commit2)
-                            args = args.extras
-                            range = [commit1, commit2]
-                          else
-                            range, opts, refs = choice_commit(multiple: view ? true : 2, values: %w[Options Pathspec])
-                            range = range.reverse
-                            args = OptionPartition.strip(opts)
-                            args.concat(refs.shellsplit) if refs
-                          end
+                          range = if commit1
+                                    commit2 = commithead param_guard(action, flag, args: args, key: :commit2)
+                                    args = args.extras
+                                    [commit1, commit2]
+                                  else
+                                    range, opts, refs = choice_commit(multiple: flag == :view ? true : 2,
+                                                                      values: %w[Options Pathspec])
+                                    args = OptionPartition.strip(opts)
+                                    args.concat(refs.shellsplit) if refs
+                                    range.reverse
+                                  end
                           __send__(action == 'log' ? :log! : :diff, flag, args, range: range)
                         end
                       end
@@ -565,7 +540,11 @@ module Squared
                           index = choice_commit(multiple: true)
                         else
                           index = []
-                          args.each { |val| index << (commithead(val) || commithash(val) || break) }
+                          args.each do |val|
+                            break unless (sha = commithead(val) || commithash(val))
+
+                            index << sha
+                          end
                           args = args.drop(index.size)
                         end
                         diff(flag, args, index: index)
@@ -577,36 +556,36 @@ module Squared
                         diff(flag, args.extras, branch: branch)
                       end
                     when :files
-                      format_desc action, flag, 'path1,path2'
-                      task flag, [:path1, :path2] do |_, args|
+                      format_desc action, flag, 'path1,path2,patch?'
+                      task flag, [:path1, :path2, :patch] do |_, args|
                         path1 = param_guard(action, flag, args: args, key: :path1)
                         path2 = param_guard(action, flag, args: args, key: :path2)
-                        diff(flag, refs: [path1, path2])
+                        diff(flag, refs: [path1, path2, args.patch])
                       end
                     end
                   when 'checkout'
                     case flag
                     when :branch
-                      format_desc action, flag, 'name,create?=[bB],commit?,detach?=d'
+                      format_desc action, flag, 'name,create?=[bB],commit?,d/etach?'
                       task flag, [:name, :create, :commit, :detach] do |_, args|
                         if (branch = args.name)
                           branch = param_guard(action, flag, args: args, key: :name)
                           create = args.create
-                          if args.commit == 'd'
-                            detach = 'd'
-                            commit = nil
-                          elsif create == 'd'
-                            create = nil
-                            commit = nil
-                            detach = 'd'
-                          elsif create && create.size > 1
-                            commit = commithead create
-                            create = nil
-                            detach = args.commit
-                          else
-                            detach = args.detach
-                            commit = commithead args.commit
-                          end
+                          detach = if args.commit == 'd'
+                                     commit = nil
+                                     'd'
+                                   elsif create == 'd'
+                                     create = nil
+                                     commit = nil
+                                     'd'
+                                   elsif create && create.size > 1
+                                     commit = commithead create
+                                     create = nil
+                                     args.commit
+                                   else
+                                     commit = commithead args.commit
+                                     args.detach
+                                   end
                           param_guard(action, flag, args: { create: create }, key: :create, pat: /\A[Bb]\z/) if create
                         else
                           branch = choice_refs 'Choose a branch to switch'
@@ -619,7 +598,7 @@ module Squared
                         if (origin = args.origin)
                           branch = args.name
                         else
-                          origin, branch = choice_refs('Choose a remote', 'remotes', values: ['Enter branch name'])
+                          origin, branch = choice_refs('Choose a remote', 'remotes', values: 'Enter branch name')
                         end
                         checkout(flag, branch: branch, origin: origin)
                       end
@@ -630,7 +609,7 @@ module Squared
                         args = if commit
                                  args.extras
                                else
-                                 commit, opts = choice_commit(values: ['Options'])
+                                 commit, opts = choice_commit(values: 'Options')
                                  OptionPartition.strip(opts)
                                end
                         checkout(flag, args, commit: commit)
@@ -640,7 +619,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)
@@ -654,11 +633,13 @@ module Squared
                   when 'branch'
                     case flag
                     when :create
-                      format_desc action, flag, 'name,ref?=HEAD|:'
+                      format_desc action, flag, 'name,ref?|:'
                       task flag, [:name, :ref] do |_, args|
                         target = param_guard(action, flag, args: args, key: :name)
                         ref = commithead args.ref
-                        ref, remote = choice_refs('Choose a remote', 'remotes', accept: [['Push?', true]]) if ref == ':'
+                        if ref == ':'
+                          ref, remote = choice_refs('Choose a remote', 'remotes', accept: [accept_b('Push?')])
+                        end
                         branch(flag, target: target, ref: ref, remote: remote)
                       end
                     when :track
@@ -668,18 +649,18 @@ module Squared
                           target = args.name
                           remote = true if ref.delete_prefix!('~')
                         else
-                          ref, remote, target = choice_refs('Choose a remote', 'remotes', accept: [['Push?', true]],
-                                                                                          values: ['Enter branch name'])
+                          ref, remote, target = choice_refs('Choose a remote', 'remotes', accept: [accept_b('Push?')],
+                                                                                          values: 'Enter branch name')
                         end
                         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 == ':')
                           accept = ['Delete?']
-                          accept << ['Force?', true] unless r
+                          accept << accept_b('Force?') unless r
                           remote = choice_refs('Choose a branch', r ? 'remotes' : 'heads', multiple: true,
                                                                                            accept: accept)
                           if r
@@ -697,7 +678,12 @@ module Squared
                       task flag do |_, args|
                         branch flag, args.to_a
                       end
-                    when :move, :copy
+                    when :current
+                      format_desc action, flag
+                      task flag do
+                        branch flag
+                      end
+                    else
                       format_desc action, flag, 'branch,oldbranch?'
                       task flag, [:branch, :oldbranch] do |_, args|
                         if (branch = args.branch)
@@ -708,24 +694,19 @@ module Squared
                         end
                         branch(flag, refs: [oldbranch, branch])
                       end
-                    else
-                      format_desc action, flag
-                      task flag do
-                        branch flag
-                      end
                     end
                   when 'switch'
                     case flag
                     when :create
-                      format_desc action, flag, '(^)name,ref?=HEAD|:'
+                      format_desc action, flag, '(^)name,ref?|:'
                       task flag, [:name, :commit] do |_, args|
                         branch = param_guard(action, flag, args: args, key: :name)
                         commit = commithead args.commit
-                        commit, track = choice_commit(values: ['Track? [Y/n]'], force: false) if commit == ':'
+                        commit, track = choice_commit(force: false, values: 'Track? [Y/n]') if commit == ':'
                         switch(flag, branch: branch, commit: commit, track: track)
                       end
                     when :detach
-                      format_desc action, flag, 'ref?=HEAD'
+                      format_desc action, flag, 'ref?'
                       task flag, [:commit] do |_, args|
                         commit = commithead(args.commit) || choice_commit(force: false)
                         switch(flag, commit: commit)
@@ -733,12 +714,12 @@ module Squared
                     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
+                        args = if (branch = args.name)
+                                 branch = nil if branch == ':'
+                                 args.extras
+                               else
+                                 []
+                               end
                         switch(flag, args, branch: branch || choice_refs('Choose a branch'))
                       end
                     end
@@ -748,26 +729,26 @@ module Squared
                       format_desc action, flag, 'ref|:,opts*'
                       task flag, [:commit] do |_, args|
                         commit = commithead args.commit
-                        if commit && commit != ':'
-                          args = args.extras
-                        else
-                          commit, mode = choice_commit(values: ['Mode [mixed|soft|hard|N]'])
-                          args = args.extras.concat(case mode&.downcase
+                        args = if commit && commit != ':'
+                                 args.extras
+                               else
+                                 commit, mode = choice_commit(values: ['Mode [mixed|soft|hard|N]'])
+                                 args.extras.concat(case mode&.downcase
                                                     when 'h', 'hard' then ['hard']
                                                     when 's', 'soft' then ['soft']
-                                                    when 'n', 'N' then ['mixed', 'N']
+                                                    when 'n', 'N' then %w[mixed N]
                                                     else ['mixed']
                                                     end)
-                        end
-                        print_success if success?(reset(flag, args, commit: commit))
+                               end
+                        success?(reset(flag, args, commit: commit))
                       end
                     when :index, :undo
-                      format_desc(action, flag, flag == :index ? 'opts*,pathspec*' : nil)
+                      format_desc(action, flag, ('opts*,pathspec*' if flag == :index))
                       task flag do |_, args|
                         reset(flag, flag == :index ? args.to_a : [])
                       end
                     when :mode
-                      format_desc action, flag, 'mode,ref?=HEAD|:'
+                      format_desc action, flag, 'mode,ref?|:'
                       task flag, [:mode, :ref] do |_, args|
                         mode = param_guard(action, flag, args: args, key: :mode)
                         ref = commithead args.ref
@@ -775,7 +756,7 @@ module Squared
                         reset(flag, mode: mode, ref: ref)
                       end
                     when :patch
-                      format_desc action, flag, 'ref?=HEAD|:,pathspec*'
+                      format_desc action, flag, 'ref?|:,pathspec*'
                       task flag, [:ref] do |_, args|
                         ref = commithead args.ref
                         ref = choice_commit(reflog: false) unless ref && ref != ':'
@@ -804,18 +785,18 @@ module Squared
                   when 'rebase', 'merge'
                     case flag
                     when :branch
-                      format_desc action, flag, 'upstream,branch?=HEAD,opts*'
+                      format_desc action, flag, 'upstream,branch?,opts*'
                       task flag, [:upstream] do |_, args|
                         args = if (upstream = args.upstream)
                                  args.extras
                                else
-                                 upstream, opts = choice_refs('Choose upstream branch', values: ['Options'])
+                                 upstream, opts = choice_refs('Choose upstream branch', values: 'Options')
                                  OptionPartition.strip(opts)
                                end
                         rebase(flag, args, upstream: upstream)
                       end
                     when :onto
-                      format_desc action, flag, 'ref,upstream,branch?=HEAD'
+                      format_desc action, flag, 'ref,upstream,branch?'
                       task flag, [:commit, :upstream, :branch] do |_, args|
                         commit = commithead args.commit
                         args = if commit
@@ -824,7 +805,7 @@ module Squared
                                  []
                                else
                                  commit = choice_refs 'Choose "onto" branch'
-                                 target, opts = choice_commit(reflog: false, multiple: 2, values: ['Options'])
+                                 target, opts = choice_commit(reflog: false, multiple: 2, values: 'Options')
                                  branch, upstream = target
                                  OptionPartition.strip(opts)
                                end
@@ -836,7 +817,7 @@ module Squared
                         args = args.to_a
                         if args.empty?
                           accept = "Merge with #{`#{git_output('branch --show-current')}`.chomp}?"
-                          branch, opts = choice_refs('Choose a branch', values: ['Options'], accept: accept)
+                          branch, opts = choice_refs('Choose a branch', values: 'Options', accept: accept)
                           args = OptionPartition.strip(opts)
                         end
                         merge(flag, args, branch: branch)
@@ -852,7 +833,7 @@ module Squared
                   when 'rev'
                     case flag
                     when :commit
-                      format_desc action, flag, 'ref?=HEAD,size?'
+                      format_desc action, flag, 'ref?,size?'
                       task flag, [:ref, :size] do |_, args|
                         ref = commithead args.ref
                         size = args.size
@@ -863,8 +844,6 @@ module Squared
                         rev_parse(flag, ref: ref, size: size)
                       end
                     when :build
-                      next unless build?
-
                       format_desc action, flag, 'opts*'
                       task flag do |_, args|
                         revbuild flag, args.to_a
@@ -882,7 +861,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*', after: ('pathspec*' if action == 'files'))
                       task flag do |_, args|
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
@@ -923,16 +902,22 @@ module Squared
                     end
                   when 'git'
                     before = case flag
-                             when :blame then 'file'
-                             when :mv then 'source+,destination'
-                             when :revert then 'commit+'
+                             when :blame
+                               'file'
+                             when :mv
+                               'source+,destination'
+                             when :revert
+                               'commit+'
                              end
-                    format_desc(action, flag, 'opts*', before: before, after: case flag
-                                                                              when :add
-                                                                                'pathspec*,pattern*'
-                                                                              when :clean, :rm, :status
-                                                                                'pathspec*'
-                                                                              end)
+                    after = case flag
+                            when :add
+                              'pathspec*,pattern*'
+                            when :grep
+                              'tree*,pathspec*'
+                            when :clean, :rm, :status
+                              'pathspec*'
+                            end
+                    format_desc(action, flag, 'opts*', before: before, after: after)
                     task flag do |_, args|
                       __send__(flag == :status ? :status : :git, flag, args.to_a)
                     end
@@ -983,8 +968,12 @@ module Squared
                 printsucc
               end
               op = OptionPartition.new(opts, OPT_GIT[:pull], cmd, project: self, no: OPT_GIT[:no][:pull])
-              opts -= op.extras
-              reg = matchmap op
+              reg = if op.empty?
+                      []
+                    else
+                      opts = op.uniq(opts)
+                      matchmap op
+                    end
               session_done op.target
               heads = []
               cur = nil
@@ -993,10 +982,10 @@ module Squared
                 cur ||= line.delete_prefix!('* ')
                 heads << line if matchany?(line, reg)
               end
-              raise_error('head not found', hint: 'for-each-ref') unless cur
+              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
+              (heads.dup << cur).each_with_index do |branch, i|
+                next unless (i < heads.size && cur != branch) || i == heads.size
 
                 git_spawn 'switch --quiet', force && '--force', shell_quote(branch)
                 pull(nil, opts, sync: false, hint: branch) if heads.include?(branch)
@@ -1010,8 +999,8 @@ module Squared
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag, from: :pull)
           source(sync: sync, sub: if stdout?
                                     [
-                                      { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: color(:red), index: 4 },
-                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, styles: color(:green), index: 3 }
+                                      opt_style(color(:red), /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, 4),
+                                      opt_style(color(:green), /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, 3)
                                     ]
                                   end, hint: hint, **threadargs)
         end
@@ -1027,7 +1016,7 @@ module Squared
 
             op = OptionPartition.new(opts, OPT_GIT[:rebase], cmd, project: self, no: OPT_GIT[:no][:rebase])
             op << upstream
-            append_head op.shift
+            append_head op.shift&.delete_prefix(':')
             op.clear(pass: false)
           when :onto
             return unless upstream
@@ -1039,13 +1028,13 @@ module Squared
           else
             unless gitpath('REBASE_HEAD').exist?
               puts log_message(Logger::INFO, name, 'no rebase in progress', hint: command) if stdout?
-              return
+              exit 1
             end
             return unless VAL_GIT[:rebase][:send].include?(command)
 
             cmd << "--#{command}"
           end
-          source(sync: sync)
+          source
         end
 
         def autostash(*, sync: invoked_sync?('autostash'), **)
@@ -1089,22 +1078,33 @@ module Squared
           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))
           if flag
-            if flag == :all
+            case flag
+            when :all
               opts << 'include-untracked'
               flag = :push
+            when :staged
+              opts << 'staged'
+              flag = :push
+            when :worktree
+              opts << 'keep-index'
+              flag = :push
+            end
+            unless (file = gitpath('logs/refs/stash')).exist? || flag == :push
+              puts log_message(Logger::INFO, name, 'no stashes were found', hint: flag) if stdout?
+              exit 1
             end
             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]
+              list.concat(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)
+            op = OptionPartition.new(opts, list, cmd, project: self, no: no, first: (matchpathspec if flag == :push))
             case flag
             when :push
               op.append?('message', readline('Enter message', force: true), force: true) if op.remove(':')
@@ -1115,30 +1115,32 @@ module Squared
                   if op.empty?
                     values = [['Branch name', true]]
                   else
-                    op << op.shift
+                    op.add_first(prefix: ':')
                   end
                 end
                 out = choice_index('Choose a stash', git_spawn('stash list', stdout: false),
-                                   values: values, column: /^[^@]+@\{(\d+)\}/)
+                                   values: values, column: /^[^@]+@\{(\d+)}/, force: true)
                 if values
                   op.merge(out.reverse)
                 else
                   op << out
                 end
               elsif !op.empty?
-                op << op.shift
+                op.add_first(prefix: ':')
               elsif flag == :branch
-                raise_error 'no branch name'
+                raise_error ArgumentError, 'no branch name'
               end
               op.clear
             when :clear
-              source(stdout: true) if confirm("Remove #{sub_style('all', styles: theme[:active])} stash entries?", 'N')
+              n = sub_style(file.read.lines.size, styles: theme[:inline])
+              s = sub_style(name, styles: theme[:active])
+              source(stdout: true) if confirm("Remove #{n} stash entries from #{s}?", 'N')
               return
             when :list
               op.clear
               out, banner, from = source(io: true)
               print_item banner
-              list_result(write_lines(out), 'objects', banner: banner, from: from)
+              list_result(write_lines(out), 'objects', from: from)
               return
             end
           else
@@ -1176,18 +1178,18 @@ module Squared
             g = color(:green)
             sub = if session_arg?('short')
                     [
-                      { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
-                      { pat: /^([A-Z?!])(.+)$/, styles: g },
-                      { pat: /^(\?\?)(.+)$/, styles: r },
-                      { pat: /^(## )((?~\.{3}))(\.{3})(.+)$/, styles: [nil, g, nil, r], index: -1 }
+                      opt_style(r, /^(.)([A-Z?!])(.+)$/, 2),
+                      opt_style(g, /^([A-Z?!])(.+)$/),
+                      opt_style(r, /^(\?\?)(.+)$/),
+                      opt_style([nil, g, nil, r], /^(## )((?~\.{3}))(\.{3})(.+)$/, -1)
                     ]
                   else
-                    [{ pat: /^(\t+)([a-z]+: +.+)$/, styles: r, index: 2 }]
+                    opt_style(r, /^(\t+)([a-z]+: +.+)$/, 2)
                   end
           end
           out, banner, from = source(io: true)
           ret = write_lines(out, banner: banner, sub: sub)
-          list_result(ret, 'files', action: 'modified', banner: banner, from: from)
+          list_result(ret, 'files', from: from, action: 'modified')
         end
 
         def revbuild(flag = nil, opts = [], sync: nil, **kwargs)
@@ -1216,26 +1218,24 @@ module Squared
             op.clear(append: true)
             args = op.to_a
           else
-            args = []
-            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) }
+            args = [
+              option('untracked-files', prefix: 'git') { |val| basic_option('untracked-files', val) },
+              option('ignore-submodules', prefix: 'git') { |val| basic_option('ignore-submodules', val) },
+              option('ignored', prefix: 'git') { |val| basic_option('ignored', val) }
+            ].compact
           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?
+              workspace.rev_timeutc(name, 'build') unless (since = workspace.rev_timesince(name, 'build'))
               if stdout?
-                if (since = workspace.rev_timesince(name, 'build'))
-                  puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: "#{since} ago")
-                else
-                  workspace.rev_timeutc(name, 'build')
-                end
+                puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: since && "#{since} ago")
               end
               return
             end
           end
           start = time_epoch
-          build(*@output, sync: sync, from: :'git:revbuild')
+          build(@output, sync: sync, from: :'git:revbuild')
         rescue StandardError => e
           print_error(e, pass: true)
         else
@@ -1248,9 +1248,8 @@ module Squared
           cmd, opts = git_session('reset', opts: opts)
           case flag
           when :commit, :index
-            op = OptionPartition.new(opts, OPT_GIT[:reset] + VAL_GIT[:reset], cmd,
-                                     project: self, no: OPT_GIT[:no][:reset],
-                                     first: flag == :index ? matchpathspec : nil)
+            op = OptionPartition.new(opts, OPT_GIT[:reset] + VAL_GIT[:reset] + OPT_GIT[:log][:diff_context], cmd,
+                                     project: self, no: OPT_GIT[:no][:reset], first: (matchpathspec if flag == :index))
             if flag == :commit
               op.append(commit)
                 .clear(pass: false)
@@ -1281,7 +1280,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 'f', 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
@@ -1294,13 +1293,13 @@ module Squared
             cmd << '-m' if merge
             cmd << '--detach' << commit
           else
-            op = OptionPartition.new(opts, OPT_GIT[:checkout], cmd, project: self, no: OPT_GIT[:no][:checkout],
-                                                                    first: flag == :path ? matchpathspec : nil)
+            list = OPT_GIT[:checkout] + OPT_GIT[:log][:diff_context]
+            op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GIT[:no][:checkout],
+                                                      first: (matchpathspec if flag == :path))
             if flag == :path
               append_head
               append_pathspec(op.extras, pass: false)
-              print_success if success?(source)
-              return
+              return success?(source)
             end
             op.append(commit)
               .clear(pass: false)
@@ -1317,7 +1316,7 @@ module Squared
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
-            cmd << '--force' if option('force', 'f')
+            cmd << '--force' if option('f', 'force')
             if !commit && message && (sha = commithash(message))
               commit = sha
               message = nil
@@ -1333,12 +1332,15 @@ module Squared
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, grep: op.extras)
-            list_result(ret, 'tags', grep: op.extras, banner: banner, from: from)
+            list_result(ret, 'tags', from: from, grep: op.extras)
             return
           end
-          remote ||= option 'remote'
-          source
-          git_spawn('push', flag == :delete ? '-d' : nil, remote, *refs.map { |val| shell_quote(val) }) if remote
+          remote ||= option('remote')
+          source.tap do |ret|
+            next unless ret && remote
+
+            git_spawn('push', ('-d' if flag == :delete), remote, *refs.map! { |val| shell_quote(val) })
+          end
         end
 
         def log!(flag, opts = [], range: [], index: [])
@@ -1356,13 +1358,14 @@ module Squared
           append_pathspec op.extras
           source(exception: false)
         end
-        alias log_ log!
 
         def diff(flag, opts = [], refs: [], branch: nil, range: [], index: [])
           cmd, opts = git_session('diff', opts: opts)
-          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff], cmd,
+          op = OptionPartition.new(opts,
+                                   collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff] + OPT_GIT[:log][:diff_context],
+                                   cmd,
                                    project: self, no: OPT_GIT[:no][:log][:diff],
-                                   first: flag == :files ? nil : matchpathspec)
+                                   first: (matchpathspec unless flag == :files))
           case flag
           when :files, :view, :between, :contain
             op.delete('--cached')
@@ -1370,7 +1373,16 @@ module Squared
           append_nocolor
           if flag == :files
             op << '--no-index'
+            patch = refs.pop
             append_pathspec(refs, parent: true)
+            if patch
+              patch = basepath patch
+              exit 1 if patch.exist? && !confirm_basic('Overwrite?', patch)
+              op << '>' << shell_quote(patch)
+              source(banner: false)
+              puts patch.read if patch.exist? && (stdin? || verbose?)
+              return
+            end
           else
             op << '--merge-base' if option('merge-base')
             case flag
@@ -1383,7 +1395,7 @@ module Squared
               op.add_quote(branch) if branch
               if !index.empty?
                 if op.arg?('cached')
-                  raise_error("one commit only: #{index.join(', ')}", hint: 'cached') if index.size > 1
+                  raise_error "single commit: #{index.join(', ')}", hint: 'cached' unless index.size == 1
                   op << index.first
                 else
                   op.merge(index)
@@ -1399,7 +1411,7 @@ module Squared
 
         def commit(flag, opts = [], refs: [], ref: nil, squash: nil, pick: nil, message: nil, pass: false)
           fixup = flag == :fixup
-          amend = !fixup && flag.to_s.start_with?('amend')
+          amend = flag.match?(/^amend/) && !fixup
           unless flag == :add || pick == 'reword'
             pathspec = if flag == :all || ((fixup || amend) && refs.size == 1 && refs.first == '*')
                          '--all'
@@ -1410,9 +1422,9 @@ module Squared
                        end
           end
           if fixup
-            source git_session('commit', basic_option('fixup', "#{pick ? "#{pick}:" : ''}#{ref}"), pathspec)
-            source git_output('rebase --autosquash', squash) if squash.is_a?(String)
-            return
+            ret = source(git_session('commit', basic_option('fixup', pick ? "#{pick}:#{ref}" : ref), pathspec))
+            source git_output('rebase --autosquash', squash) if ret && squash.is_a?(String)
+            return ret
           end
           message ||= messageopt
           if !message && !amend
@@ -1424,7 +1436,8 @@ module Squared
           origin = nil
           upstream = nil
           cmd, opts = git_session('add', opts: opts)
-          op = OptionPartition.new(opts, OPT_GIT[:add], cmd, project: self, first: matchpathspec)
+          op = OptionPartition.new(opts, OPT_GIT[:add] + OPT_GIT[:log][:diff_context], cmd,
+                                   project: self, no: OPT_GIT[:no][:add], first: matchpathspec)
           op << '--verbose' if verbose
           format = '%(if)%(HEAD)%(then)%(refname:short)...%(upstream:short)...%(upstream:track)%(end)'
           git_spawn 'fetch --no-tags --quiet'
@@ -1433,10 +1446,9 @@ 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?
+              raise_error 'work tree is not usable', hint: hint[1..-2]
+            elsif (!origin || origin.empty?) && !dryrun?
               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))
@@ -1445,6 +1457,7 @@ module Squared
                 end
                 origin = readline('Enter an upstream', force: true)
               end
+              raise_error ArgumentError, 'missing remote name', hint: origin unless origin.include?('/')
               upstream = true
             end
             break
@@ -1455,14 +1468,13 @@ module Squared
             append_pathspec op.extras
           end
           co = git_session('commit', options: false)
-          pu = git_output 'push'
-          co << '--amend' if amend
-          pu << '--set-upstream' if upstream
+          pu = git_output 'push', upstream && '--set-upstream'
           if dryrun?
-            op.adjoin('--dry-run')
+            op.delete('--dry-run')
             co << '--dry-run'
             pu << '--dry-run'
           end
+          co << '--amend' if amend
           if message
             append_message message
           elsif flag == :'amend-orig' || option('edit', equals: '0')
@@ -1470,6 +1482,7 @@ module Squared
           end
           pu << '--force-with-lease' if amend
           pu.merge(repotrack(origin, branch))
+          puts if pass
           adding = git_spawn 'diff --name-only --no-color'
           source op
           cached = git_spawn 'diff --cached --name-only --no-color'
@@ -1479,10 +1492,13 @@ module Squared
             end
             source co
             source pu
-          elsif banner?
-            puts 'Nothing to commit'
-          elsif stdout?
-            puts log_message(Logger::INFO, name, 'nothing to commit', hint: flag)
+          else
+            if banner?
+              puts 'Nothing to commit'
+            elsif stdout?
+              puts log_message(Logger::INFO, name, 'nothing to commit', hint: flag)
+            end
+            exit 1
           end
         end
 
@@ -1492,26 +1508,25 @@ module Squared
           case flag
           when :commit, :'no-commit'
             op = OptionPartition.new(opts, OPT_GIT[:merge], cmd, project: self, no: OPT_GIT[:no][:merge])
-            op << "--#{flag}"
-            op.delim
+            op << "--#{flag}" << '--'
             if branch
               op << branch
               op.clear(pass: false)
             else
-              raise_error 'no branch/commit' if op.empty?
+              raise_error ArgumentError, '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
+              exit 1
             end
             return unless VAL_GIT[:merge][:send].include?(command)
 
             cmd << "--#{command}"
             display = command == 'abort'
           end
-          print_success if success?(source, display)
+          success?(source, display)
         end
 
         def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil, remote: nil)
@@ -1529,11 +1544,11 @@ module Squared
                        '--track'
                      end
             end
-            cmd << '--force' if option('force', 'f')
+            cmd << '--force' if option('f', 'force')
             cmd << shell_quote(target)
             cmd << shell_quote(ref) if ref
           when :track
-            raise_error('invalid upstream', hint: ref) unless ref.include?('/')
+            raise_error 'invalid upstream', hint: ref unless ref.include?('/')
             if ref.delete_prefix!('^')
               cmd << '--unset-upstream' << shell_quote(ref)
               remote = false
@@ -1544,7 +1559,7 @@ 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.start_with?(/[~^]/) }
             force.each do |val|
@@ -1558,13 +1573,13 @@ module Squared
             remote = nil
           when :move, :copy
             s = +"-#{flag.to_s[0]}"
-            s.upcase! if option('force', 'f')
+            s.upcase! if option('f', 'force')
             cmd << s
             refs.compact.each { |val| cmd << shell_quote(val) }
             stdout = true
           when :current
             cmd << '--show-current'
-            source(banner: verbosetype > 1, stdout: true)
+            source(banner: verbose?, stdout: true)
             return
           when :list
             op = OptionPartition.new(opts, OPT_GIT[:branch], cmd << '--list',
@@ -1573,10 +1588,10 @@ module Squared
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
-              { pat: /^(\*\s+)(\S+)(.*)$/, styles: color(:green), index: 2 },
-              { pat: %r{^(\s*)(remotes/\S+)(.*)$}, styles: color(:red), index: 2 }
+              opt_style(color(:green), /^(\*\s+)(\S+)(.*)$/, 2),
+              opt_style(color(:red), %r{^(\s*)(remotes/\S+)(.*)$}, 2)
             ])
-            list_result(ret, 'branches', banner: banner, from: from)
+            list_result(ret, 'branches', from: from)
             return
           else
             if (head = git_spawn('rev-parse --abbrev-ref HEAD').chomp).empty?
@@ -1599,7 +1614,7 @@ module Squared
                   r3 = write.call($4, $5)
                 end
                 r1 = nil if r1 == "origin/#{data[0]}"
-                [" Branch: #{a + (r1 ? " (#{r1})" : '')}", r2, r3, " Commit: #{b}", "Message: #{r[2]}"]
+                [" Branch: #{a.subhint(r1)}", r2, r3, " Commit: #{b}", "Message: #{r[2]}"]
                   .compact
                   .join("\n")
               end
@@ -1608,21 +1623,17 @@ module Squared
             print_error(name, 'no ref found', subject: 'branch', hint: 'head', pass: true) if ret == 0
             return
           end
-          return unless success?(source(stdout: stdout))
+          return unless success?(source(stdout: stdout), !ref && flag == :create) && !ref && remote && target
 
-          if !ref
-            print_success if flag == :create
-          elsif remote && target
-            source git_output('push -u', shell_quote(ref.split('/', 2).first), shell_quote(target))
-          end
+          source git_output('push -u', shell_quote(ref.split('/', 2).first), shell_quote(target))
         end
 
         def switch(flag, opts = [], branch: nil, commit: nil, track: nil)
           cmd, opts = git_session('switch', opts: opts)
-          cmd << '--force' if option('force', 'f')
+          cmd << '--force' if option('f', 'force')
           if flag == :branch
-            op = OptionPartition.new(opts, OPT_GIT[:switch], cmd, project: self, no: OPT_GIT[:no][:switch])
-            op.add_quote(branch)
+            OptionPartition.new(opts, OPT_GIT[:switch], cmd, project: self, no: OPT_GIT[:no][:switch])
+                           .add_quote(branch)
           else
             case flag
             when :create
@@ -1652,16 +1663,18 @@ module Squared
             op.add_quote(branch, '--', path, url)
           else
             op.adjoin(flag)
-            op << '--recursive' if option('recursive', 'r')
+            op << '--recursive' if option('r', 'recursive')
             op.splice(path: true)
           end
-          print_success if success?(source, flag == :branch)
+          source.tap { |ret| success?(ret, flag == :branch) }
         end
 
         def restore(flag, opts = [], commit: nil, files: nil)
           cmd, opts = git_session('restore', shell_option(flag, commit, escape: false, force: false), opts: opts)
-          op = OptionPartition.new(opts, OPT_GIT[:restore], cmd, project: self, no: OPT_GIT[:no][:restore],
-                                                                 first: matchpathspec)
+          op = OptionPartition.new(opts,
+                                   OPT_GIT[:restore] + OPT_GIT[:log][:diff_context],
+                                   cmd,
+                                   project: self, no: OPT_GIT[:no][:restore], first: matchpathspec)
           append_pathspec(op.extras + (files || []), pass: false)
           source(sync: false, stderr: true)
         end
@@ -1687,9 +1700,9 @@ module Squared
           else
             opts << format if format
           end
-          op = OptionPartition.new(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff], cmd,
-                                   project: self,
-                                   no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log], pass: [:base]))
+          list = OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff] + OPT_GIT[:log][:diff_context]
+          op = OptionPartition.new(opts, list, cmd, project: self, pass: [:base],
+                                                    no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log]))
           op.append(delim: true)
           source(exception: false, banner: flag != :oneline)
         end
@@ -1698,7 +1711,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'
@@ -1708,85 +1721,100 @@ module Squared
               cmd << '--sq-quote'
               args = true
             end
-            op = OptionPartition.new(opts, OPT_GIT[:rev_parse], cmd, project: self, no: OPT_GIT[:no][:rev_parse],
-                                                                     args: args)
-            op.append(escape: args)
+            OptionPartition.new(opts, OPT_GIT[:rev_parse], cmd, project: self, no: OPT_GIT[:no][:rev_parse], args: args)
+                           .append(escape: args)
           end
-          source(banner: verbosetype > 1)
+          source(banner: verbose?)
         end
 
         def ls_remote(flag, opts = [], remote: nil)
-          cmd, opts = git_session('ls-remote', '--refs', opts: opts)
+          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
           out, banner, from = source(io: true)
           print_item banner
-          ret = write_lines(out, grep: op.extras)
-          list_result(ret, flag.to_s, grep: op.extras, banner: banner, from: from)
+          ret = write_lines(out, grep: op.extras, prefix: "refs/#{flag}/")
+          list_result(ret, flag.to_s, from: from, grep: op.extras)
         end
 
         def ls_files(flag, opts = [])
-          cmd, opts = git_session('ls-files', "--#{flag}", opts: 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)
-          list_result(ret, 'files', grep: op.extras, banner: banner, from: from)
+          list_result(ret, 'files', from: from, grep: op.extras)
         end
 
         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, [])
+          list.concat(OPT_GIT[:log][:diff_context]) if flag == :add
+          op = OptionPartition.new(opts, list, cmd, project: self, no: OPT_GIT[:no][flag], single: /\A\d+\z/,
+                                                    first: case flag
+                                                           when :blame, :revert then nil
+                                                           else matchpathspec
+                                                           end)
           case flag
           when :blame
-            raise_error 'no file found' unless (n = op.index { |s| basepath(s).file? })
-            op.delim << shell_quote(basepath(op.delete_at(n)))
-            op.clear
+            raise_error Errno::ENOENT, 'no file target' unless (n = op.index { |s| basepath(s).file? })
+            op.append(basepath(op.remove_at(n)), delim: true)
+              .clear
           when :revert
             if VAL_GIT[:rebase][:send].any? { |val| op.arg?(val) }
               op.clear
             elsif op.empty?
-              raise_error 'no commit given'
+              raise_error 'no commit target'
             else
               append_commit(*op.extras)
             end
           when :add
             if flag == :add && !op.arg?('pathspec-from-file')
-              grep, list = op.partition { |val| OptionPartition.pattern?(val) }
-              unless grep.empty? && !list.empty?
+              grep, pathspec = op.partition { |val| OptionPartition.pattern?(val) }
+              unless grep.empty? && !pathspec.empty?
                 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 = [].tap do |out|
+                  status_data.each do |a, b|
+                    next if b.strip.empty? || (!grep.empty? && grep.none? { |pat| pat.match?(a) })
 
-                  files << "#{sub_style(b, styles: color(:red))} #{a}"
+                    out << "#{sub_style(b, styles: color(:red))} #{a}"
+                  end
                 end
                 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: [accept_y('Add?')])
                 end
-                op.swap(list + files)
+                op.swap(pathspec + 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'))
-            return
+            return success?(source) if flag == :add && !op.arg?('verbose')
           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 :grep
+            op.each do |val|
+              if op.include?('--')
+                op.add_path(val)
+              elsif op.exist?(val, glob: true)
+                op << '--'
+                op.add_path(val)
+              else
+                op.add_quote(val)
+              end
+            end
+          end
+          case flag
+          when :revert, :mv, :rm
+            source(sync: false, stderr: true)
+          else
+            source
           end
-          source(sync: false, stderr: true)
         end
 
         def clone?
@@ -1805,10 +1833,6 @@ module Squared
 
         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)
-          unless cmd
-            print_error('no git session started', subject: project, hint: from, pass: true)
-            return
-          end
           cmd = cmd.target if cmd.is_a?(OptionPartition)
           if io && banner == false
             from = nil
@@ -1818,20 +1842,15 @@ module Squared
               banner = nil unless banner? && !multiple
               args = true
             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|git-dir)/) }
+            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|git-dir)/) } if cmd.respond_to?(:temp)
             from = nil if from == false
           end
           cmd = session_done cmd
           log&.info cmd
-          banner = if banner
-                     banner = (banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), '')
-                     format_banner(hint ? "#{banner} (#{hint})" : banner)
-                   end
+          banner = format_banner(banner.is_a?(String) ? banner : cmd, hint: hint, strip: true) if banner
           on :first, from
           begin
             if io
@@ -1840,11 +1859,13 @@ module Squared
               return args ? [IO.popen(cmd), banner || '', from] : IO.popen(cmd)
             elsif stdin? ? sync : stdout
               print_item banner unless multiple
-              ret = `#{cmd}`.chomp
-              if !ret.empty?
+              ret = `#{cmd}`
+              raise(ret.chomp.empty? ? $?.to_s : ret) unless $?.success?
+
+              if ret.empty?
+                success?(nil, !banner.nil?)
+              else
                 puts ret
-              elsif success?(!banner.nil?)
-                print_success
               end
             elsif !kwargs[:sub] && (sync || (!exception && !stderr))
               print_item banner unless multiple
@@ -1856,7 +1877,7 @@ module Squared
                   n = write_lines(out, banner: banner, pass: true, **kwargs)
                   if n == 0
                     n = write_lines(err, banner: banner)
-                    print_success if success?(n == 0 && !banner.nil?)
+                    success?(nil, n == 0 && !banner.nil?)
                   else
                     write_lines(err, loglevel: Logger::DEBUG)
                   end
@@ -1875,17 +1896,14 @@ 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)
-          sub = nil if stdin?
+          grep = (matchmap(grep, prefix) unless grep.empty?)
+          sub = (as_a sub unless stdin?)
           ret = 0
           out = []
           data.each do |line|
             next if grep&.none? { |pat| pat.match?(line) }
+            next if block_given? && !(line = yield line)
 
-            if block_given?
-              line = yield line
-              next unless line
-            end
             if loglevel
               log&.add loglevel, line
             else
@@ -1899,24 +1917,18 @@ module Squared
             ret += 1
             break if first
           end
-          if banner && (ret > 0 || (!pass && !first))
-            if banner.empty?
-              print_item(*out)
-            else
-              print_item(banner, *out)
-            end
-          end
+          print_item banner, out if banner && (ret > 0 || (!pass && !first))
           ret
         end
 
-        def list_result(size, type, action: 'found', grep: [], banner: nil, from: nil)
+        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? && (banner.nil? || (banner.is_a?(String) && !banner.empty?))
+          elsif stdout?
             styles = theme.fetch(:banner, []).reject { |s| s.to_s.end_with?('!') }
             styles << :bold if styles.size <= 1
             puts print_footer("#{size} #{size == 1 ? type.sub(/(?:(?<!l)e)?s\z/, '') : type}",
-                              sub: [{ pat: /^(\d+)(.+)$/, styles: styles }])
+                              sub: opt_style(styles, /^(\d+)(.+)$/))
           end
           on :last, from
         end
@@ -1932,7 +1944,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
 
@@ -1965,17 +1977,17 @@ module Squared
         end
 
         def status_data(*args)
-          ret = []
-          git_spawn('status -z -uall', *args).split("\x0").each do |line|
-            next unless line =~ /^(.)(.) (.+)$/
+          [].tap do |ret|
+            git_spawn('status -z -uall', *args).split("\x0").each do |line|
+              next unless line =~ /^(.)(.) (.+)$/
 
-            ret << [$3, $2, $1]
+              ret << [$3, $2, $1]
+            end
           end
-          ret
         end
 
         def append_pull(opts, list, target: @session, flag: nil, no: nil, remote: nil, from: nil)
-          target << '--force' if option('force', 'f', target: target)
+          target << '--force' if option('f', 'force', target: target)
           append_submodules(target: target, from: from)
           return if !remote && opts.empty?
 
@@ -1987,6 +1999,7 @@ module Squared
               when 'rebase'
                 op << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
               when 'shallow-since'
+                require 'date'
                 op.append?($1) { Date.parse($2).strftime('%F %T') }
               when 'recurse-submodules'
                 op.append?($1, $2, type: :basic)
@@ -2001,7 +2014,7 @@ module Squared
           end
           op << '--verbose' if (flag || from == :fetch) && stdout? && !op.arg?('quiet')
           if remote
-            op.append(remote)
+            op.append(remote, delim: true)
             if (val = option('refspec', target: target, strict: true))
               op.append(*split_escape(val))
             else
@@ -2046,9 +2059,7 @@ module Squared
 
         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)
@@ -2066,9 +2077,7 @@ module Squared
               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 { |path| target << basic_option('recurse-submodules', path) }
               end
             else
               target << case val
@@ -2115,28 +2124,24 @@ module Squared
                                                                       stdout: stdout, banner: banner, **kwargs)
         end
 
-        def dryrun?(*, target: @session, **)
-          return false unless target
-
-          target.include?('--dry-run') || !option('dry-run', target: target).nil?
+        def dryrun?(*, target: @session, prefix: target&.first)
+          Array(target).include?('--dry-run') || !option('dry-run', target: target, prefix: prefix).nil?
         end
 
         def quiet?(*, target: @session, **)
           return false unless target
 
-          target.include?('--quiet') || (target.include?('-q') && stripext(target.first) == 'git')
+          target.include?('--quiet') || (target.include?('-q') && target.first.stripext == 'git')
         end
 
         def gitpath(*args)
-          path.join('.git', *args)
+          basepath('.git', *args)
         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}")
-          [origin[0..(i - 1)], branch].tap { |ret| ret.map! { |val| shell_quote(val) } if quote }
+          i = origin.index('/')
+          branch = "#{branch}:#{origin[i.succ..-1]}" unless origin.end_with?("/#{branch}")
+          [origin[0..i.pred], branch].tap { |ret| ret.map! { |val| shell_quote(val) } if quote }
         end
 
         def commithash(val)