squared 0.6.17 → 0.7.0

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

@@ -84,7 +84,7 @@ module Squared
       def revbuild(file: nil)
         @revfile = @home.join(file || "#{@main}.revb")
         @revdoc = JSON.parse(@revfile.read) if @revfile.exist?
-      rescue StandardError => e
+      rescue => e
         @revfile = nil
         warn log_warn(e, pass: true)
         self
@@ -117,7 +117,7 @@ module Squared
 
       def rev_timesince(*keys, clock: false)
         epoch = time_epoch - rev_entry(*keys).to_i
-      rescue StandardError
+      rescue
         nil
       else
         time_format(epoch, clock: clock)
@@ -140,7 +140,8 @@ module Squared
           rev_timeutc(name, utc) if utc
         end
         File.write(@revfile, JSON.pretty_generate(@revdoc))
-      rescue StandardError => e
+      rescue => e
+        log&.debug e
         warn log_warn(e, pass: true) if warning
       ensure
         @revlock = false
@@ -168,28 +169,29 @@ module Squared
           }.freeze,
           fetch: {
             base: %w[multiple porcelain progress P|prune-tags refetch stdin u|update-head-ok
-                     recurse-submodules-default=b?].freeze,
+                     recurse-submodules-default=b].freeze,
             pull: %w[4 6 n t a|append atomic dry-run f|force k|keep negotiate-only prefetch p|prune q|quiet set-upstream
                      unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q recurse-submodules=v
                      refmap=q o|server-option=q shallow-exclude=b shallow-since=v upload-pack=q].freeze
           }.freeze,
           git: {
-            add: %w[N|intent-to-add].freeze,
+            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 diff-algorithm=b encoding=b ignore-rev=b ignore-revs-file=p reverse=q].freeze,
+                      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=n
+                     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? n|no-commit reference cleanup=b gpg-sign=b? m|mainline=i s|signoff strategy=b
                        X|strategy-option=b].freeze,
             rm: %w[r cached f|force n|dry-run ignore-unmatch pathspec-file-nul q|quiet sparse
-                   pathspec-from-file=p].freeze
+                   pathspec-from-file=p].freeze,
+            'sparse-checkout': %w[cone sparse-index no-cone no-sparse-index skip-checks].freeze
           }.freeze,
           log: {
             base: %w[L=qm all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
@@ -241,6 +243,10 @@ module Squared
                         show-object-format=b? since=q tags=q? until=q].freeze,
           show: %w[t combined-all-paths no-diff-merges remerge-diff show-notes-by-default show-signature diff-merges=b
                    encoding=b expand-tabs=i notes=q show-notes=q?].freeze,
+          sparse_checkout: {
+            add: %w[skip-checks].freeze,
+            clean: %w[n f v].freeze
+          }.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
@@ -253,7 +259,7 @@ module Squared
           submodule: {
             status: %w[cached recursive].freeze,
             update: %w[checkout f|force init merge N|no-fetch no-recommend-shallow no-single-branch recommend-shallow
-                       rebase recursive remote single-branch depth=i filter=q jobs=i reference=q ref-format=q].freeze,
+                       rebase recursive remote single-branch depth=i filter=q jobs=i reference=b ref-format=q].freeze,
             branch: %w[b|branch d|default].freeze,
             sync: %w[recursive].freeze
           }.freeze,
@@ -286,6 +292,10 @@ module Squared
             rev_parse: %w[flags].freeze,
             revert: %w[edit gpg-sign rerere-autoupdate].freeze,
             show: %w[standard-notes].freeze,
+            sparse_checkout: {
+              reapply: %w[cone sparse-index].freeze,
+              clean: %w[dry-run force verbose].freeze
+            }.freeze,
             status: %w[ahead-behind column renames].freeze,
             switch: %w[guess progress recurse-submodules track].freeze,
             tag: %w[column].freeze
@@ -319,13 +329,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 grep mv revert rm status].freeze,
+          'git' => %i[add blame clean grep mv revert rm sparse-checkout status].freeze,
           'log' => %i[view grep between contain].freeze,
           'merge' => %i[commit no-commit send].freeze,
           'pull' => %i[origin remote all].freeze,
@@ -333,8 +343,9 @@ module Squared
           'refs' => %i[heads tags remote].freeze,
           'reset' => %i[commit index patch mode undo].freeze,
           'restore' => %i[source staged worktree].freeze,
-          'rev' => %i[commit build output].freeze,
+          'rev' => %i[commit branch build output].freeze,
           'show' => %i[format oneline textconv].freeze,
+          'sparse-checkout' => %i[add reapply list clean disable].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,
@@ -425,7 +436,7 @@ module Squared
                                    end
                           if squash
                             found = false
-                            git_spawn('log --format=%h', stdout: false).each do |val|
+                            git_spawn(git_output('log --format=%h'), stdout: false).each do |val|
                               if found
                                 squash = val.chomp
                                 break
@@ -478,9 +489,8 @@ module Squared
                                                                          ])
                                    choice_remote
                                  end
-                        tag(flag, refs: [name], message: message, commit: commit, remote: remote).tap do |ret|
-                          success?(ret, !remote)
-                        end
+                        ret = tag(flag, refs: [name], message: message, commit: commit, remote: remote)
+                        success?(ret, !remote)
                       end
                     end
                   when 'stash'
@@ -504,16 +514,15 @@ module Squared
                             args.shift
                             index = choice_commit(multiple: true)
                           else
-                            index = []
-                            args.each do |val|
+                            index = args.each_with_object([]) do |val, out|
                               if matchhead(val)
-                                index << commithead(val)
+                                out << commithead(val)
                               elsif (sha = commithash(val))
-                                index << sha
+                                out << sha
                               elsif val.start_with?('^')
-                                index << shell_quote(val)
+                                out << shell_quote(val)
                               else
-                                break
+                                break out
                               end
                             end
                             args = args.drop(index.size)
@@ -546,11 +555,10 @@ module Squared
                           args.shift
                           index = choice_commit(multiple: true)
                         else
-                          index = []
-                          args.each do |val|
-                            break unless (sha = commithead(val) || commithash(val))
+                          index = args.each_with_object([]) do |val, out|
+                            break out unless (sha = commithead(val) || commithash(val))
 
-                            index << sha
+                            out << sha
                           end
                           args = args.drop(index.size)
                         end
@@ -696,12 +704,12 @@ module Squared
                       format_desc action, flag, '[^~]name*,:?'
                       task flag do |_, args|
                         refs = args.to_a
-                        if refs.empty? || (r = refs.last == ':')
+                        if refs.empty? || (i = refs.last == ':')
                           accept = ['Delete?']
-                          accept << accept_b('Force?') unless r
-                          remote = choice_refs('Choose a branch', r ? 'remotes' : 'heads', multiple: true,
+                          accept << accept_b('Force?') unless i
+                          remote = choice_refs('Choose a branch', i ? 'remotes' : 'heads', multiple: true,
                                                                                            accept: accept)
-                          if r
+                          if i
                             refs.pop
                           else
                             refs = remote.first
@@ -716,7 +724,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)
@@ -727,11 +740,6 @@ 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
@@ -881,6 +889,12 @@ module Squared
                         end
                         rev_parse(flag, ref: ref, size: size)
                       end
+                    when :branch
+                      format_desc action, flag, 'ref?=HEAD|upstream|push'
+                      task flag, [:ref] do |_, args|
+                        ret = rev_parse(flag, ref: args.ref || 'upstream')
+                        puts ret unless ret.empty?
+                      end
                     when :build
                       next unless build?
 
@@ -926,20 +940,28 @@ module Squared
                       task flag do |_, args|
                         args = args.to_a
                         if args.empty? || args.last == ':'
-                          files = []
-                          status_data.each { |row| files << row[0] if row[flag == :staged ? 2 : 1].match?(/[AMDRTC]/) }
+                          files = status_data.each_with_object([]) do |row, out|
+                            out << row[0] if row[flag == :staged ? 2 : 1].match?(/[AMDRTC]/)
+                          end
                           unless files.empty?
                             files = choice_index('Select a file', files, multiple: true, force: false,
                                                                          accept: 'Restore?')
                           end
                           args.pop
-                          args, glob = args.partition { |val| val.match?(/^(?:[a-z-]+=|[^*]+$)/) }
+                          args, glob = args.partition { |val| val.match?(/^([a-z-]+=|[^*]+$)/) }
                           files.concat(glob)
                           next if args.empty? && files.empty?
                         end
                         restore(flag, args, files: files)
                       end
                     end
+                  when 'sparse-checkout'
+                    break unless matchfile(gitpath('config.worktree'), /\bsparseCheckout\s+=\s+true/)
+
+                    format_desc(action, flag, 'opts*', after: ('dir+' if flag == :add))
+                    task flag do |_, args|
+                      sparse_checkout flag, args.to_a
+                    end
                   when 'git'
                     before = case flag
                              when :blame
@@ -954,6 +976,8 @@ module Squared
                               'pathspec*,pattern*'
                             when :grep
                               'tree*,pathspec*'
+                            when :'sparse-checkout'
+                              'dir+'
                             when :clean, :rm, :status
                               'pathspec*'
                             end
@@ -1008,18 +1032,21 @@ module Squared
                 printsucc
               end
               op = OptionPartition.new(opts, OPT_GIT[:pull], cmd, project: self, no: OPT_GIT[:no][:pull])
-              opts -= op.extras
-              reg, neg = matchmap(op, negate: true)
+              reg = if op.empty?
+                      []
+                    else
+                      opts = op.uniq(opts)
+                      matchmap op
+                    end
               session_done op.target
               heads = []
               cur = nil
               foreachref('heads', format: '%(if)%(HEAD)%(then)* %(end)%(refname:short)').each do |line|
-                line.chomp!
                 cur ||= line.delete_prefix!('* ')
-                heads << line if matchany?(line, reg) && !matchany?(neg, line, empty: false)
+                heads << line if matchany?(reg, line)
               end
               raise_error 'head not found', hint: 'for-each-ref' unless cur
-              opts << 'ff-only' if opts.empty? && !option('ff-only', equals: '0')
+              opts << 'ff-only' if opts.empty? && option('ff-only', notequals: '0')
               (heads.dup << cur).each_with_index do |branch, i|
                 next unless (i < heads.size && cur != branch) || i == heads.size
 
@@ -1033,12 +1060,16 @@ module Squared
           end
           append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
                       flag: flag, from: :pull, remote: remote, no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull])
-          source(sync: sync, sub: if stdout?
-                                    [
-                                      opt_style(color(:red), /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, 4),
-                                      opt_style(color(:green), /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, 3)
-                                    ]
-                                  end, hint: hint, **threadargs)
+          if sync
+            source(hint: hint)
+          else
+            source(sync: false, sub: if stdout?
+                                       [
+                                         opt_style(color(:red), /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, 4),
+                                         opt_style(color(:green), /^(.+)(\|\s+\d+\s+)(\++)(.*)$/, 3)
+                                       ]
+                                     end, hint: hint, **threadargs)
+          end
         end
 
         def rebase(flag = nil, opts = [], sync: invoked_sync?('rebase', flag), commit: nil, upstream: nil, branch: nil,
@@ -1082,7 +1113,11 @@ module Squared
           opts << 'all' if flag == :all || option('all')
           append_pull(opts, collect_hash(OPT_GIT[:fetch]), flag: flag, from: :fetch, remote: remote,
                                                            no: collect_hash(OPT_GIT[:no][:fetch]))
-          source(sync: sync, **threadargs)
+          if sync
+            source
+          else
+            source(sync: false, **threadargs)
+          end
         end
 
         def clone(*, sync: invoked_sync?('clone'), **)
@@ -1121,7 +1156,7 @@ module Squared
           option('no-tags') { opts[:'no-tags'] = true }
           opts.delete(:'recurse-submodules') || opts.delete(:'no-recurse-submodules') if append_submodules(from: :clone)
           append_hash opts
-          cmd << '--quiet' if quiet? || option('quiet')
+          cmd << '--quiet' if option('quiet') || !verbose
           append_value(data[0], path, delim: true)
           source(sync: sync, banner: sync && !quiet?, multiple: !sync || quiet?)
         end
@@ -1185,15 +1220,19 @@ module Squared
               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
             git_session('stash', 'push', opts: opts)
-            append_option(OptionPartition.select(OPT_GIT[:stash][:push], no: false), no: true, ignore: false)
+            append_option(*OptionPartition.select(OPT_GIT[:stash][:push], no: false), no: true, ignore: false)
             append_message
           end
-          source(sync: sync, banner: !quiet?, **threadargs)
+          if sync
+            source(banner: !quiet?)
+          else
+            source(sync: false, banner: !quiet?, **threadargs)
+          end
         end
 
         def status(flag = nil, opts = [])
@@ -1206,12 +1245,10 @@ module Squared
             cmd << '--branch' if option('branch')
             option('ignore-submodules', ignore: false) do |val|
               cmd << basic_option('ignore-submodules', case val
-                                                       when '0', 'none'
+                                                       when 'none', '0', 'false'
                                                          'none'
-                                                       when '1', 'untracked'
-                                                         'untracked'
-                                                       when '2', 'dirty'
-                                                         'dirty'
+                                                       when 'untracked', 'dirty'
+                                                         val
                                                        else
                                                          'all'
                                                        end)
@@ -1234,10 +1271,10 @@ module Squared
           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', action: 'modified', from: from)
         end
 
-        def revbuild(flag = nil, opts = [], sync: nil, **kwargs)
+        def revbuild(flag = nil, opts = [], **kwargs)
           kw = lambda do
             {
               include: relativepath(*Array(kwargs[:include]), all: true),
@@ -1255,7 +1292,7 @@ module Squared
           sha = git_spawn('rev-parse --verify HEAD').chomp
           return if sha.empty?
 
-          sync = invoked_sync?('revbuild', flag) if sync.nil?
+          sync = kwargs.fetch(:sync) { invoked_sync?('revbuild', flag) }
           kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? kw.call : @revbuild || {}
           case flag
           when :build
@@ -1278,11 +1315,11 @@ module Squared
             end
           end
           start = time_epoch
-          build(*@output, sync: sync, from: :'git:revbuild')
-        rescue StandardError => e
+          build(*@output, sync: sync, from: symjoin('git', 'revbuild'))
+        rescue => e
           print_error(e, pass: true)
         else
-          print_status('revbuild', subject: name, start: start, from: :completed)
+          print_status('revbuild', subject: name, start: start)
           workspace.rev_write(name, { 'revision' => sha, 'files' => status_digest(*args, **kwargs) },
                               sync: sync, utc: 'build')
         end
@@ -1336,9 +1373,9 @@ module Squared
             cmd << '-m' if merge
             cmd << '--detach' << commit
           else
-            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))
+            op = OptionPartition.new(opts, OPT_GIT[:checkout] + OPT_GIT[:log][:diff_context], cmd,
+                                     project: self, no: OPT_GIT[:no][:checkout],
+                                     first: (matchpathspec if flag == :path))
             if flag == :path
               append_head
               append_pathspec(op.extras, pass: false)
@@ -1375,18 +1412,20 @@ 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', grep: op.extras, from: from)
             return
           end
-          remote ||= option('remote')
-          source.tap { |ret| git_spawn('push', ('-d' if flag == :delete), remote, *refs.quote!) if ret && remote }
+          if (ret = source) && (remote ||= option('remote'))
+            git_spawn('push', ('-d' if flag == :delete), remote, *refs.quote!)
+          end
+          ret
         end
 
         def log!(flag, opts = [], range: [], index: [], grep: [])
           cmd, opts = git_session('log', opts: opts)
-          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd,
-                                   project: self, no: collect_hash(OPT_GIT[:no][:log]),
-                                   first: matchpathspec)
+          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd, project: self,
+                                                                           no: collect_hash(OPT_GIT[:no][:log]),
+                                                                           first: matchpathspec)
           case flag
           when :between, :contain
             op.add_quote(range.join(flag == :between ? '..' : '...'))
@@ -1399,7 +1438,6 @@ 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)
@@ -1484,7 +1522,7 @@ module Squared
           format = '%(if)%(HEAD)%(then)%(refname:short)...%(upstream:short)...%(upstream:track)%(end)'
           git_spawn 'fetch --no-tags --quiet'
           foreachref('heads', format: format).each do |line|
-            next if (line = line.chomp).empty?
+            next if line.empty?
 
             branch, origin, hint = line.split('...')
             if hint && !hint.match?(/^\[(\D+0,\D+0)\]$/)
@@ -1529,7 +1567,7 @@ module Squared
           cached = git_spawn 'diff --cached --name-only --no-color'
           if amend || !cached.empty? || dryrun?
             if adding.empty? && !cached.empty? && banner?
-              puts(cached.lines(chomp: true).map! { |val| "cached #{shell_quote(val)}" })
+              puts(cached.lines(chomp: true).map { |val| "cached #{shell_quote(val)}" })
             end
             source co
             source pu
@@ -1601,7 +1639,7 @@ module Squared
             end
           when :delete
             remote&.each { |val| source git_output('push --delete', *val.split('/', 2).quote!) }
-            force, list = refs.partition { |val| val.start_with?(/[~^]/) }
+            force, list = refs.partition { |val| val.start_with?('~', '^') }
             force.each do |val|
               r = '-r' if val.delete!('~')
               source git_output('branch', val.delete!('^') ? '-D' : '-d', r, shell_quote(val))
@@ -1631,7 +1669,7 @@ module Squared
               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?
@@ -1640,7 +1678,7 @@ module Squared
               git_spawn 'fetch --all --prune --quiet' if option('sync')
               cmd << '-vv --no-abbrev --list'
               out, banner, from = source(io: true)
-              first = from_base?('branch')
+              first = workspace.size > 1
               grep = first ? [/^\*\s+#{Regexp.escape(head)}\s/] : []
               ret = write_lines(out, grep: grep, banner: banner, first: first) do |line, index|
                 next line if stdin?
@@ -1708,12 +1746,14 @@ module Squared
             op << '--recursive' if option('r', 'recursive')
             op.splice(path: true)
           end
-          source.tap { |ret| success?(ret, flag == :branch) }
+          success?(source, 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] + OPT_GIT[:log][:diff_context], cmd,
+          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)
@@ -1726,7 +1766,7 @@ module Squared
             cmd << '--textconv'
             append_value(files.flat_map { |val| Dir[val] }
                               .select { |val| projectpath?(val) }
-                              .map! { |val| shell_quote("HEAD:#{val}") })
+                              .map { |val| shell_quote("HEAD:#{val}") })
             source(banner: false)
             return
           when :oneline
@@ -1741,9 +1781,8 @@ module Squared
             opts << format if format
           end
           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,
-                                   no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log], pass: [:base]))
+          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
@@ -1755,8 +1794,13 @@ module Squared
             cmd << (size.to_i.zero? ? '--verify' : basic_option('short', [size.to_i, 5].max))
             append_commit(ref, head: true)
           when :branch
-            cmd << '--abbrev-ref'
-            append_commit(ref, head: true)
+            cmd << '--abbrev-ref' << '--symbolic-full-name' << shell_quote(case ref
+                                                                           when 'upstream', 'push'
+                                                                             "@{#{ref}}"
+                                                                           else
+                                                                             ref
+                                                                           end)
+            return git_spawn(cmd, exception: false).chomp
           when :output
             if opts.delete('sq-quote')
               cmd << '--sq-quote'
@@ -1768,6 +1812,20 @@ module Squared
           source(banner: verbose?)
         end
 
+        def sparse_checkout(flag, opts = [])
+          cmd, opts = git_session('sparse-checkout', flag, opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:sparse_checkout].fetch(flag, []), cmd,
+                                   project: self, no: OPT_GIT[:no][:sparse_checkout][flag])
+          case flag
+          when :add
+            append_pathspec(op.detach, expect: true, resolve: false, pass: false)
+          when :clean
+            op << '--dry-run' unless op.arg?('n', 'f', 'force')
+          end
+          op.clear
+          success?(source, flag != :list)
+        end
+
         def ls_remote(flag, opts = [], remote: nil)
           cmd, opts = git_session('ls-remote --refs', opts: opts)
           cmd << "--#{flag}" unless flag == :remote
@@ -1776,7 +1834,7 @@ module Squared
           out, banner, from = source(io: true)
           print_item banner
           ret = write_lines(out, grep: op.extras, prefix: "refs/#{flag}/")
-          list_result(ret, flag.to_s, grep: op.extras, banner: banner, from: from)
+          list_result(ret, flag.to_s, grep: op.extras, from: from)
         end
 
         def ls_files(flag, opts = [])
@@ -1786,7 +1844,7 @@ module Squared
           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', grep: op.extras, from: from)
         end
 
         def git(flag, opts = [])
@@ -1797,10 +1855,12 @@ module Squared
             list.concat(OPT_GIT[:log][:diff_context])
           when :revert
             list.concat(VAL_GIT[:rebase][:send])
+          when :'sparse-checkout'
+            cmd << 'set'
           end
           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
+                                                           when :blame, :revert, :'sparse-checkout' then nil
                                                            else matchpathspec
                                                            end)
           case flag
@@ -1821,12 +1881,12 @@ module Squared
               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|
+                files = status_data.map do |a, b|
                   next if b.strip.empty? || (!grep.empty? && grep.none? { |pat| pat.match?(a) })
 
-                  files << "#{sub_style(b, color(:red))} #{a}"
+                  "#{sub_style(b, color(:red))} #{a}"
                 end
+                .compact
                 unless files.empty?
                   files = choice_index('Select files', files, multiple: true, trim: /^\S+\s/,
                                                               accept: [accept_y('Add?')])
@@ -1835,23 +1895,17 @@ module Squared
               end
             end
             return source(git_session('status -s'), banner: false) unless append_pathspec(op.extras)
-            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 :rm, :clean, :'sparse-checkout'
+            append_pathspec(op.extras, expect: flag != :clean, resolve: flag != :'sparse-checkout')
           when :grep
-            delim = false
             op.each do |val|
-              if val == '--'
-                delim = true
-                op.delim
-              elsif delim
+              if op.include?('--')
                 op.add_path(val)
               elsif op.exist?(val, glob: true)
-                delim = true
                 op.delim
                   .add_path(val)
               else
@@ -1863,7 +1917,7 @@ module Squared
           when :revert, :mv, :rm
             source(sync: false, stderr: true)
           else
-            source
+            success?(source, flag == :'sparse-checkout' || (flag == :add && !op.arg?('verbose')))
           end
         end
 
@@ -1882,31 +1936,28 @@ module Squared
         private
 
         def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
-                   multiple: false, hint: nil, from: nil, send: :system, **kwargs)
-          unless cmd
-            print_error('no git session started', subject: project, hint: from, pass: true)
-            return
-          end
+                   multiple: false, hint: nil, from: nil, timeout: nil, send: :system, **kwargs)
           cmd = cmd.target if cmd.is_a?(OptionPartition)
           if io && banner == false
             from = nil
             banner = nil
-            args = false
           else
+            if banner
+              banner = nil unless banner? && !multiple
+              args = true
+            end
             if from == false
               from = nil
             elsif !from && cmd.respond_to?(:drop)
               from = cmd.drop(1).find { |val| val.match?(/\A[a-z]{1,2}[a-z-]*\z/) }
-              from &&= :"git:#{from}"
-            end
-            if banner
-              banner = cmd.temp { |val| val.start_with?(/--(work-tree|git-dir)/) } if cmd.respond_to?(:temp)
-              args = true
+              from &&= symjoin 'git', from
             end
+            banner &&= cmd.temp { |val| val.start_with?(/--(work-tree|git-dir)/) } if cmd.respond_to?(:temp)
           end
+          timeout = session_timeout cmd if timeout.nil?
           cmd = session_done cmd
-          log&.info cmd unless args == false
-          banner = if banner && banner? && !multiple
+          log&.info cmd
+          banner = if banner
                      format_banner(banner.is_a?(String) ? banner : cmd, hint: hint, strip: true)
                    end
           on :first, from
@@ -1917,7 +1968,11 @@ module Squared
               return args ? [IO.popen(cmd), banner || '', from] : IO.popen(cmd)
             elsif stdin? ? sync : stdout
               print_item banner unless multiple
-              ret = `#{cmd}`.chomp
+              ret = if stdin? && timeout.to_f > 0
+                      Timeout.timeout(timeout) { `#{cmd}` }
+                    else
+                      `#{cmd}`
+                    end.chomp
               raise(ret.empty? ? $?.to_s : ret) unless $?.success?
 
               if ret.empty?
@@ -1927,25 +1982,17 @@ module Squared
               end
             elsif !kwargs[:sub] && (sync || (!exception && !stderr))
               print_item banner unless multiple
-              ret = shell(cmd, name: send, exception: exception)
+              ret = shell_t(cmd, name: send, exception: exception, timeout: timeout)
+            elsif timeout.to_f > 0
+              Timeout.timeout(timeout) { run_e(cmd, stderr: stderr, banner: banner, **kwargs) }
             else
-              require 'open3'
-              if stderr
-                Open3.popen3(cmd) do |_, out, err|
-                  n = write_lines(out, banner: banner, pass: true, **kwargs)
-                  if n == 0
-                    n = write_lines(err, banner: banner)
-                    success?(n == 0, n == 0 && !banner.nil?)
-                  else
-                    write_lines(err, loglevel: Logger::DEBUG)
-                  end
-                end
-              else
-                Open3.popen2e(cmd) { |_, out| write_lines(out, banner: banner, **kwargs) }
-              end
+              run_e(cmd, stderr: stderr, banner: banner, **kwargs)
             end
-          rescue StandardError => e
-            on_error(e, from, pass: true)
+          rescue Timeout::Error => e
+            print_error(Logger::ERROR, cmd, subject: name, hint: e)
+            exit 1 unless exception?(Logger::DEBUG, Logger::INFO)
+          rescue => e
+            on_error(e, pass: true)
             nil
           else
             on :last, from
@@ -1953,42 +2000,10 @@ module Squared
           end
         end
 
-        def write_lines(data, grep: [], prefix: nil, sub: nil, banner: nil, loglevel: nil, pass: false, first: false)
-          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, ret))
-
-            if loglevel
-              log&.add loglevel, line
-            else
-              sub&.each { |h| sub_style!(line, **h) }
-              if banner
-                out << line
-              else
-                puts line
-              end
-            end
-            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
-          ret
-        end
-
-        def list_result(size, type, action: 'found', grep: [], banner: nil, from: nil)
+        def list_result(size, type, action: 'found', grep: [], 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}",
@@ -2020,7 +2035,7 @@ module Squared
           ret = choice_index('Choose a commit', git_spawn(cmd, stdout: false), column: /^(\S+)/, force: force, **kwargs)
           case ret
           when Array
-            ret.map { |val| val&.stripstyle }
+            ret.map(&:stripstyle)
           when String
             ret.stripstyle
           else
@@ -2038,24 +2053,18 @@ module Squared
           algorithm ||= Digest::SHA256
           glob = kwargs.fetch(:include, [])
           pass = kwargs.fetch(:exclude, [])
-          ret = {}
-          status_data(*args).each do |file,|
+          status_data(*args).map(&:first).each_with_object({}) do |file, out|
             next if !glob.empty? && glob.none? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
             next if pass.any? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
 
-            ret[file] = algorithm.hexdigest(File.read(basepath(file)))
+            out[file] = algorithm.hexdigest(File.read(basepath(file)))
           end
-          ret
         end
 
         def status_data(*args)
-          ret = []
-          git_spawn('status -z -uall', *args).split("\x0").each do |line|
-            next unless line =~ /^(.)(.) (.+)$/
-
-            ret << [$3, $2, $1]
+          git_spawn('status -z -uall', *args).split("\x0").each_with_object([]) do |line, out|
+            out << [$3, $2, $1] if line =~ /^(.)(.) (.+)$/
           end
-          ret
         end
 
         def append_pull(opts, list, flag:, from:, target: @session, no: nil, remote: nil)
@@ -2063,9 +2072,8 @@ module Squared
           append_submodules(target: target, from: from)
           return if !remote && opts.empty?
 
-          refspec = []
           op = OptionPartition.new(opts, remote ? list + ['refspec=v'] : list, target, project: self, no: no)
-          op.each do |opt|
+          refspec = op.each_with_object([]) do |opt, out|
             if opt =~ op.values
               case $1
               when 'rebase'
@@ -2076,7 +2084,7 @@ module Squared
               when 'recurse-submodules'
                 op.append?($1, $2, type: :basic)
               when 'refspec'
-                refspec << shell_quote($2)
+                out << shell_quote($2)
               end
             elsif op.arg?('multiple')
               op.found << opt
@@ -2086,9 +2094,9 @@ 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))
+              op.append(split_escape(val))
             else
               op.merge(refspec)
             end
@@ -2102,27 +2110,31 @@ module Squared
           op.clear(errors: true, subject: flag) if flag
         end
 
-        def append_commit(*val, target: @session, head: false)
-          val.compact!
-          if !val.empty?
-            val.each { |ref| target << (commithash(ref) || shell_quote(ref)) }
+        def append_commit(*refs, target: @session, head: false)
+          refs.compact!
+          if !refs.empty?
+            target.merge(refs.map { |val| commithash(val) || shell_quote(val) })
           elsif head
             target << (append_head(target: target) || 'HEAD')
           end
         end
 
-        def append_pathspec(files = [], target: @session, expect: false, parent: false, pass: true)
+        def append_pathspec(files = [], target: @session, expect: false, **kwargs)
           if session_arg?('pathspec-from-file', target: target)
-            option_clear files
+            OptionPartition.clear(target, files, styles: theme[:inline])
             true
           else
             option('pathspec', target: target) { |val| files = split_escape(val) } if files.empty?
-            files = projectmap(files, parent: parent, pass: pass)
+            files = projectmap(files, **kwargs)
             if !files.empty?
               target << '--' << files.join(' ')
               true
             elsif expect
-              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree')
+              raise_error(if expect.is_a?(String)
+                            expect
+                          else
+                            kwargs[:parent] ? 'pathspec not present' : 'pathspec not within worktree'
+                          end)
             else
               false
             end
@@ -2131,7 +2143,9 @@ module Squared
 
         def append_message(val = nil, target: @session)
           val = messageopt if val.to_s.empty?
-          target << quote_option('message', val) if val
+          return unless val
+
+          target << quote_option('message', val)
         end
 
         def append_head(val = nil, target: @session)
@@ -2164,11 +2178,15 @@ module Squared
           end
         end
 
-        def foreachref(path, *args, format: nil)
-          path = Array(path).map! { |val| "refs/#{val}" }
+        def foreachref(path, *args, format: nil, chomp: true)
+          path = Array(path).map { |val| "refs/#{val}" }
           format &&= quote_option('format', format)
           ret = git_spawn('for-each-ref', format, *args, *path, stdout: workspace.windows?)
-          ret.is_a?(String) ? ret.lines : ret
+          if ret.is_a?(String)
+            ret.lines(chomp: chomp)
+          else
+            chomp ? ret.readlines(chomp: chomp) : ret
+          end
         end
 
         def git_session(*cmd, opts: nil, worktree: true, **kwargs)
@@ -2196,10 +2214,14 @@ module Squared
                                                                       stdout: stdout, banner: banner, **kwargs)
         end
 
+        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 silent? unless target
+          return false unless target
 
-          silent? || target.include?('--quiet') || (target.include?('-q') && target.first.stripext == 'git')
+          target.include?('--quiet') || (target.include?('-q') && target.first.stripext == 'git')
         end
 
         def gitpath(*args)
@@ -2211,7 +2233,9 @@ module Squared
             raise_error(ArgumentError, "missing #{origin ? 'branch' : 'remote'} name", hint: origin)
           end
           branch = "#{branch}:#{origin[i.succ..-1]}" unless origin.end_with?("/#{branch}")
-          [origin[0..i.pred], branch].tap { |ret| ret.quote! if quote }
+          ret = [origin[0..i.pred], branch]
+          ret.quote! if quote
+          ret
         end
 
         def commithash(val)
@@ -2236,16 +2260,22 @@ module Squared
           [/\A[^a-z\d-]+/i, %r{\A[^=\\/*]*[\\/*]}, /\A--\z/]
         end
 
+        def matchfile(file, pat)
+          file.read[pat, 0] if file.exist?
+        rescue
+          nil
+        end
+
         def messageopt
           option('message', 'm', prefix: 'git', ignore: false)
         end
 
         def threadargs
-          { stderr: true, exception: exception || !workspace.series.multiple? }
+          { stderr: true, exception: exception? || !workspace.series.multiple? }
         end
       end
 
-      Application.implement Git
+      Application.implement Git, base: 1
     end
   end
 end