squared 0.4.6 → 0.4.8

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

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'time'
-require 'digest'
-
 module Squared
   module Workspace
     module Git
@@ -18,14 +14,14 @@ module Squared
         check = ->(proj) { proj.is_a?(Project::Git) && !proj.exclude?(Project::Git.ref) && git_clone?(proj.path) }
         if uri.is_a?(Array)
           base = name
-          uri.each { |val| repo << proj if (proj = @project[val.to_s]) && check.(proj) }
+          uri.each { |val| repo << proj if (proj = @project[val.to_s]) && check.call(proj) }
         elsif uri
           data[name.to_s] = uri
         elsif name.is_a?(Enumerable)
           data = name.to_h
         elsif name.is_a?(String) && name.match?(GIT_PROTO)
           base = name
-          @project.each_value { |proj| repo << proj if !proj.parent && check.(proj) }
+          @project.each_value { |proj| repo << proj if !proj.parent && check.call(proj) }
         else
           warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid', pass: true) if warning
           return self
@@ -141,7 +137,7 @@ module Squared
       private
 
       def rev_timenow
-        DateTime.now.strftime('%Q').to_i + time_offset
+        Time.now.utc.strftime('%s%L').to_i
       end
     end
     Application.include Git
@@ -163,11 +159,12 @@ module Squared
             show: %w[s exit-code histogram].freeze
           }.freeze,
           fetch: {
-            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok recurse-submodules=b
+            base: %w[multiple progress P|prune-tags refetch stdin u|update-head-ok
                      recurse-submodules-default=b].freeze,
             pull: %w[4 6 n t a|append atomic dry-run f|force k|keep n|negotiate-only prefetch p|prune q|quiet
                      set-upstream unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q
-                     refmap=q o|server-option=q shallow-exclude=e shallow-since=b upload-pack=q].freeze
+                     recurse-submodules=v refmap=q o|server-option=q shallow-exclude=e shallow-since=v
+                     upload-pack=q].freeze
           }.freeze,
           log: {
             base: %w[all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
@@ -199,7 +196,7 @@ module Squared
                        X|exclude-from=p exclude-per-directory=p format=q with-tree=q].freeze,
           ls_remote: %w[exit-code get-url q|quiet o|server-option=q symref sort=q upload-pack=q].freeze,
           mv: %w[k f|force n|dry-run v|verbose].freeze,
-          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=qq log=i r|rebase=b? s|strategy=b
+          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=qq log=i r|rebase=v? s|strategy=b
                    X|strategy-option=b].freeze,
           merge: %w[e n allow-unrelated-histories ff-only m=q q|quiet v|verbose cleanup=b F|file=p S|gpg-sign=qq
                     into-name=e log=i s|strategy=b X|strategy-option=b].freeze,
@@ -300,7 +297,7 @@ module Squared
           end
 
           def tasks
-            %i[pull rebase fetch clone stash status branch revbuild].freeze
+            %i[pull rebase autostash fetch clone stash status branch revbuild].freeze
           end
 
           def config?(val)
@@ -328,7 +325,7 @@ module Squared
           'rev' => %i[commit branch output parseopt build].freeze,
           'show' => %i[format oneline textconv].freeze,
           'stash' => %i[push pop apply drop clear list].freeze,
-          'tag' => %i[add delete list].freeze
+          'tag' => %i[add sign delete list].freeze
         })
 
         def initialize(*, **)
@@ -345,7 +342,7 @@ module Squared
           return unless ref?(Git.ref)
 
           namespace name do
-            @@tasks[Git.ref].each do |action, flags|
+            Git.subtasks do |action, flags|
               next if @pass.include?(action)
 
               namespace action do
@@ -386,12 +383,14 @@ module Squared
                         tag flag, args.to_a
                       end
                     when :delete
-                      format_desc action, flag, 'name+'
+                      format_desc action, flag, 'name+?'
                       task flag do |_, args|
-                        refs = param_guard(action, flag, args: args.to_a)
+                        if (refs = args.to_a).empty?
+                          refs = choice_refs('Choose a tag', 'tags', multiple: true, accept: 'Delete?')
+                        end
                         tag(flag, refs: refs)
                       end
-                    when :add
+                    when :add, :sign
                       format_desc action, flag, 'name,message?,commit?'
                       task flag, [:name, :message, :commit] do |_, args|
                         name = param_guard(action, flag, args: args, key: :name)
@@ -411,7 +410,7 @@ module Squared
                     case flag
                     when :view, :between, :contain
                       if flag == :view && action == 'log'
-                        format_desc action, flag, '(^)commit/H0*,pathspec*,opts*'
+                        format_desc action, flag, '(^)commit/H0*,opts*,pathspec*'
                         task flag do |_, args|
                           index = []
                           args.to_a.each do |val|
@@ -419,18 +418,18 @@ module Squared
                               index << "HEAD~#{$1}"
                             elsif (sha = commithash(val))
                               index << sha
-                            elsif val.start_with?('^') || (!%r{^[.\\/]}.match?(val) && !%r{[\\/]$}.match?(val))
+                            elsif val.start_with?('^')
                               index << shell_quote(val)
                             end
                           end
-                          logx(flag, args.to_a.drop(index.size), index: index)
+                          log!(flag, args.to_a.drop(index.size), index: index)
                         end
                       else
-                        format_desc action, flag, 'commit1,commit2,pathspec*,opts*'
+                        format_desc action, flag, 'commit1,commit2,opts*,pathspec*'
                         task flag, [:commit1, :commit2] do |_, args|
                           commit1 = param_guard(action, flag, args: args, key: :commit1)
                           commit2 = param_guard(action, flag, args: args, key: :commit2)
-                          __send__(action == 'log' ? :logx : :diff, flag, args.extras, range: [commit1, commit2])
+                          __send__(action == 'log' ? :log! : :diff, flag, args.extras, range: [commit1, commit2])
                         end
                       end
                     when :head
@@ -461,33 +460,41 @@ module Squared
                   when 'checkout'
                     case flag
                     when :branch
-                      format_desc action, flag, 'name,create?=[bB],commit?,detach?=d'
+                      format_desc action, flag, 'name?,create?=[bB],commit?,detach?=d'
                       task flag, [:name, :create, :commit, :detach] do |_, args|
-                        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 = create
-                          create = nil
-                          detach = args.commit
+                        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 = create
+                            create = nil
+                            detach = args.commit
+                          else
+                            detach = args.detach
+                            commit = args.commit
+                          end
+                          param_guard(action, flag, args: { create: create }, key: :create, pat: /\Ab\z/i) if create
                         else
-                          detach = args.detach
-                          commit = args.commit
+                          branch = choice_refs 'Choose a branch to switch', 'heads'
                         end
-                        param_guard(action, flag, args: { create: create }, key: :create, pat: /\Ab\z/i) if create
                         checkout(flag, branch: branch, create: create, commit: commit, detach: detach)
                       end
                     when :track
-                      format_desc action, flag, 'origin,(^)name?'
+                      format_desc action, flag, 'origin?,(^)name?'
                       task flag, [:origin, :name] do |_, args|
-                        origin = param_guard(action, flag, args: args, key: :origin)
-                        checkout(flag, branch: args.name, origin: origin)
+                        if (origin = args.origin)
+                          branch = args.name
+                        else
+                          origin, branch = choice_refs('Choose a remote', 'remotes', values: ['Enter branch name'])
+                        end
+                        checkout(flag, branch: branch, origin: origin)
                       end
                     when :commit
                       format_desc action, flag, 'branch/commit,opts*'
@@ -515,15 +522,21 @@ module Squared
                         branch(flag, target: target, ref: args.ref)
                       end
                     when :set
-                      format_desc(action, flag, '(^)upstream,name?')
+                      format_desc(action, flag, '(^)upstream?,name?')
                       task flag, [:upstream, :name] do |_, args|
-                        upstream = param_guard(action, flag, args: args, key: :upstream)
-                        branch(flag, target: args.name, ref: upstream)
+                        if (ref = args.upstream)
+                          target = args.name
+                        else
+                          ref, target = choice_refs('Choose a remote', 'remotes', values: ['Enter branch name'])
+                        end
+                        branch(flag, target: target, ref: ref)
                       end
                     when :delete
-                      format_desc action, flag, '(^~)name+'
+                      format_desc action, flag, '(^~)name+?'
                       task flag do |_, args|
-                        refs = param_guard(action, flag, args: args.to_a)
+                        if (refs = args.to_a).empty?
+                          refs = choice_refs('Choose a branch', 'heads', multiple: true, accept: 'Delete?')
+                        end
                         branch(flag, refs: refs)
                       end
                     when :edit
@@ -699,16 +712,20 @@ module Squared
         end
 
         def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
-          cmd, opts = git_session('pull', flag && "--#{flag}", opts: opts)
+          cmd, opts = git_session('pull', opts: opts)
           if flag == :rebase
+            cmd << '--rebase'
             cmd << '--autostash' if option('autostash')
-          elsif (val = option('rebase', ignore: false))
-            cmd << case val
-                   when '0'
-                     '--no-rebase'
-                   else
-                     VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
-                   end
+          else
+            cmd << '--autostash' if flag == :autostash
+            if (val = option('rebase', ignore: false))
+              cmd << case val
+                     when '0', 'false'
+                       '--no-rebase'
+                     else
+                       VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
+                     end
+            end
           end
           append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
@@ -727,15 +744,15 @@ module Squared
           cmd, opts = git_session('rebase', opts: opts)
           case flag
           when :branch
-            branch = option_sanitize(opts, OPT_GIT[:rebase], no: OPT_GIT[:no][:rebase]).first
-            case branch.size
+            op = OptionPartition.new(opts, OPT_GIT[:rebase], cmd, project: self, no: OPT_GIT[:no][:rebase])
+            case op.size
             when 0
               append_head
             when 1, 2
-              append_value(branch, delim: true)
+              op.append(delim: true)
             else
-              append_value([branch.pop, branch.pop].reverse, delim: true)
-              option_clear(branch, pass: false)
+              op.append(op.pop(2), delim: true)
+                .clear(pass: false)
             end
           when :onto
             return unless upstream
@@ -752,12 +769,16 @@ module Squared
           source
         end
 
+        def autostash(*, sync: invoked_sync?('autostash'), **)
+          pull(:autostash, sync: sync)
+        end
+
         def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
           cmd, opts = git_session('fetch', opts: opts)
-          append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]),
-                                                           remote: remote, flag: flag)
+          append_pull(opts, collect_hash(OPT_GIT[:fetch]),
+                      no: collect_hash(OPT_GIT[:no][:fetch]), remote: remote, flag: flag)
           cmd << '--all' if !remote && !session_arg?('multiple') && option('all')
-          cmd << '--verbose' if verbose && !session_arg('quiet')
+          cmd << '--verbose' if verbose && !session_arg?('quiet')
           source(sync: sync, **threadargs)
         end
 
@@ -786,25 +807,25 @@ module Squared
         def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
           if flag
             cmd, opts = git_session('stash', flag, opts: opts)
-            refs = option_sanitize(opts, OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])).first
+            op = OptionPartition.new(opts, OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, []), cmd,
+                                     project: self)
             case flag
             when :push
-              append_pathspec refs
+              append_pathspec op.extras
             when :pop, :apply, :drop
-              unless refs.empty?
-                cmd << shell_escape(refs.pop)
-                option_clear refs
+              unless op.empty?
+                op << shell_escape(op.pop)
+                op.clear
               end
             when :clear
-              if confirm("Remove #{sub_style('all', styles: theme[:active])} the stash entries? [y/N] ", 'N')
+              if confirm("Remove #{sub_style('all', styles: theme[:active])} stash entries? [y/N] ", 'N')
                 source(stdout: true)
               end
               return
             when :list
               out, banner, from = source(io: true)
               print_item banner
-              ret = write_lines(out)
-              list_result(ret, 'objects', from: from)
+              list_result(write_lines(out), 'objects', from: from)
               return
             end
           else
@@ -855,22 +876,23 @@ module Squared
           end
           unless workspace.closed
             if @revbuild
-              statusargs.().each { |key, val| @revbuild[key] += val }
+              statusargs.call.each { |key, val| @revbuild[key] += val }
             else
-              @revbuild = statusargs.()
+              @revbuild = statusargs.call
             end
             return
           end
-          sha = git_spawn('rev-parse --verify HEAD').first.to_s.chomp
+          sha = git_spawn('rev-parse --verify HEAD').chomp
           return if sha.empty?
 
-          args = []
-          kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.() : @revbuild || {}
+          kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.call : @revbuild || {}
           case flag
           when :build
-            opts = option_sanitize(opts, OPT_GIT[:status], target: args).first
-            option_clear(opts, append: true)
+            op = OptionPartition.new(opts, OPT_GIT[:status], project: self)
+            op.clear(append: true)
+            args = op.to_a
           else
+            args = []
             args << basic_option('untracked-files', flag) if (flag = option('untracked-files', prefix: 'git'))
             args << basic_option('ignore-submodules', flag) if (flag = option('ignore-submodules', prefix: 'git'))
             args << basic_option('ignored', flag) if (flag = option('ignored', prefix: 'git'))
@@ -904,13 +926,14 @@ module Squared
           cmd, opts = git_session('reset', opts: opts)
           case flag
           when :commit, :index
-            files = option_sanitize(opts, OPT_GIT[:reset] + VAL_GIT[:reset], no: OPT_GIT[:no][:reset]).first
+            op = OptionPartition.new(opts, OPT_GIT[:reset] + VAL_GIT[:reset], cmd,
+                                     project: self, no: OPT_GIT[:no][:reset])
             if flag == :commit
-              append_value(commit, delim: true)
-              option_clear(files, pass: false)
+              op.append(commit, delim: true)
+                .clear(pass: false)
               ref = false
             else
-              (refs ||= []).concat(files)
+              (refs ||= []).concat(op.extras)
             end
           when :mode
             return unless VAL_GIT[:reset].include?(mode)
@@ -922,8 +945,6 @@ module Squared
             end
           when :patch
             cmd << '--patch'
-          else
-            return
           end
           unless ref == false
             append_commit(ref, head: true)
@@ -939,26 +960,26 @@ module Squared
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
             append_option('track', equals: true)
-            cmd << (create ? shell_option(create, branch) : branch) << commit
+            cmd << (create ? quote_option(create, branch) : branch) << commit
           when :track
             if branch
               if branch.start_with?('^')
                 opt = 'B'
                 branch = branch[1..-1]
               end
-              cmd << shell_option(opt || 'b', branch)
+              cmd << quote_option(opt || 'b', branch)
             end
-            cmd << '--track' << origin
+            cmd << '--track' << shell_quote(origin)
           when :detach
             cmd << '--detach' << commit
           else
-            refs = option_sanitize(opts, OPT_GIT[:checkout], no: OPT_GIT[:no][:checkout]).first
+            op = OptionPartition.new(opts, OPT_GIT[:checkout], cmd, project: self, no: OPT_GIT[:no][:checkout])
             if flag == :commit
-              append_value(commit, delim: true)
-              option_clear(refs, pass: false)
+              op.append(commit, delim: true)
+                .clear(pass: false)
             else
               append_head
-              append_pathspec refs
+              append_pathspec op.extras
             end
           end
           source
@@ -967,12 +988,13 @@ module Squared
         def tag(flag, opts = [], refs: [], message: nil, commit: nil)
           cmd, opts = git_session('tag', opts: opts)
           case flag
-          when :add
-            if option('sign')
+          when :add, :sign
+            if flag == :sign || option('sign')
               cmd << '--sign'
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
+            cmd << '--force' if option('force')
             if !commit && message && (sha = commithash(message))
               commit = sha
             else
@@ -981,12 +1003,11 @@ module Squared
             append_value refs
             append_head commit
           when :list
-            cmd << '--list'
-            grep = option_sanitize(opts, OPT_GIT[:tag], no: OPT_GIT[:no][:tag]).first
+            op = OptionPartition.new(opts, OPT_GIT[:tag], cmd << '--list', project: self, no: OPT_GIT[:no][:tag])
             out, banner, from = source(io: true)
             print_item banner
-            ret = write_lines(out, grep: grep)
-            list_result(ret, 'tags', from: from, grep: grep)
+            ret = write_lines(out, grep: op.extras)
+            list_result(ret, 'tags', from: from, grep: op.extras)
             return
           when :delete
             cmd << '--delete'
@@ -997,57 +1018,58 @@ module Squared
           source
         end
 
-        def logx(flag, opts = [], range: [], index: [])
+        def log!(flag, opts = [], range: [], index: [])
           cmd, opts = git_session('log', opts: opts)
-          refs = option_sanitize(opts, collect_hash(OPT_GIT[:log]), no: collect_hash(OPT_GIT[:no][:log])).first
+          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:log]), cmd,
+                                   project: self, no: collect_hash(OPT_GIT[:no][:log]))
           case flag
           when :between, :contain
-            cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
+            op << shell_quote(range.join(flag == :between ? '..' : '...'))
           else
-            cmd.merge(index)
+            op.merge(index)
           end
           append_nocolor
-          append_pathspec refs
+          append_pathspec op.extras
           source(exception: false)
         end
 
         def diff(flag, opts = [], refs: [], branch: nil, range: [], index: [])
           cmd, opts = git_session('diff', opts: opts)
-          files = option_sanitize(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff],
-                                  no: OPT_GIT[:no][:log][:diff]).first
+          op = OptionPartition.new(opts, collect_hash(OPT_GIT[:diff]) + OPT_GIT[:log][:diff], cmd,
+                                   project: self, no: OPT_GIT[:no][:log][:diff])
           case flag
           when :files, :view, :between, :contain
-            cmd.delete('--cached')
+            op.delete('--cached')
           end
           append_nocolor
           if flag == :files
-            cmd << '--no-index'
+            op << '--no-index'
             append_pathspec(refs, parent: true)
           else
             case flag
             when :view
-              cmd << '--merge-base' if option('merge-base')
-              cmd << shell_quote(range.first, quote: true) << shell_quote(range.last, quote: true)
+              op << '--merge-base' if option('merge-base')
+              op << shell_quote(range.first, quote: true) << shell_quote(range.last, quote: true)
             when :between, :contain
-              cmd.delete('--merge-base')
-              cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
+              op.delete('--merge-base')
+              op << shell_quote(range.join(flag == :between ? '..' : '...'))
             else
-              cmd << '--merge-base' if option('merge-base')
-              cmd << shell_quote(branch) if branch
+              op << '--merge-base' if option('merge-base')
+              op << shell_quote(branch) if branch
               if !index.empty?
-                if session_arg?('cached')
+                if op.arg?('cached')
                   raise_error("one commit only: #{index.join(', ')}", hint: '--cached') if index.size > 1
-                  cmd << index.first
+                  op << index.first
                 else
-                  cmd.merge(index)
+                  op.merge(index)
                 end
               elsif (n = option('index', ignore: false))
-                cmd << "HEAD~#{n}"
+                op << "HEAD~#{n}"
               end
             end
-            append_pathspec files
+            append_pathspec op.extras
           end
-          source(exception: session_arg?('exit-code'))
+          source(exception: op.arg?('exit-code'))
         end
 
         def commit(flag, *, refs: [], message: nil, pass: false)
@@ -1069,7 +1091,7 @@ module Squared
           branch = nil
           upstream = nil
           git_spawn 'fetch --no-tags --quiet'
-          git_spawn('branch -vv --list', stdout: false).first.each do |val|
+          git_spawn('branch -vv --list', stdout: false).each do |val|
             next unless (r = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
 
             branch = r[1]
@@ -1077,7 +1099,7 @@ module Squared
               origin = r[3][%r{^(.+)/#{Regexp.escape(branch)}$}, 1]
             else
               unless (origin = option('repository', prefix: 'git', ignore: false))
-                out = git_spawn('log -n1 --format=%h%d').first
+                out = git_spawn 'log -n1 --format=%h%d'
                 if out =~ /^#{r[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
                   split_escape($1).each do |s|
                     next unless s.end_with?("/#{branch}")
@@ -1122,10 +1144,10 @@ module Squared
           cmd, opts = git_session('merge', opts: opts)
           case flag
           when :commit, :'no-commit'
-            refs = option_sanitize(opts, OPT_GIT[:merge], no: OPT_GIT[:no][:merge]).first
-            raise_error 'no branch/commit' if refs.empty?
-            cmd << "--#{flag}" << '--'
-            append_commit(*refs)
+            op = OptionPartition.new(opts, OPT_GIT[:merge], cmd, project: self, no: OPT_GIT[:no][:merge])
+            raise_error 'no branch/commit' if op.empty?
+            op << "--#{flag}" << '--'
+            append_commit(*op.extras)
           else
             return unless VAL_GIT[:merge][:send].include?(command)
 
@@ -1141,7 +1163,7 @@ module Squared
           when :create
             if (arg = option('track', ignore: false))
               cmd << case arg
-                     when '0'
+                     when '0', 'false'
                        '--no-track'
                      when 'direct', 'inherit'
                        basic_option('track', arg)
@@ -1162,17 +1184,17 @@ module Squared
             end
             ref = nil
           when :delete
-            force, list = refs.partition { |val| val.match?(/^[\^~]/) }
+            force, list = refs.partition { |val| val.match?(/^[~^]/) }
             force.each do |val|
               dr = val[0, 3]
               d = dr.include?('^') ? '-D' : '-d'
-              r = dr.include?('~') ? '-r' : nil
+              r = '-r' if dr.include?('~')
               source git_output('branch', d, r, shell_quote(val.sub(/^[\^~]+/, '')))
             end
             return if list.empty?
 
             cmd << '-d'
-            list.each { |val| cmd << shell_quote(val) }
+            append_value list
           when :move, :copy
             flag = "-#{flag.to_s[0]}"
             cmd << (option('force') ? flag.upcase : flag)
@@ -1182,20 +1204,22 @@ module Squared
             cmd << '--edit-description'
           when :current
             cmd << '--show-current'
+            source(banner: verbosetype > 1, stdout: true)
+            return
           when :list
-            opts = option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch], single: /^v+$/).first
-            cmd << '--list'
-            opts.each { |val| cmd << shell_quote(val) }
+            op = OptionPartition.new(opts, OPT_GIT[:branch], cmd << '--list',
+                                     project: self, no: OPT_GIT[:no][:branch], single: /^v+$/)
+            op.each { |val| op << shell_quote(val) }
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
-              { pat: /^(\*\s+)(\S+)(\s*)$/, styles: color(:green), index: 2 },
+              { pat: /^(\*\s+)(\S+)(.*)$/, styles: color(:green), index: 2 },
               { pat: %r{^(\s*)(remotes/\S+)(.*)$}, styles: color(:red), index: 2 }
             ])
             list_result(ret, 'branches', from: from)
             return
           else
-            head = git_spawn('rev-parse --abbrev-ref HEAD').first.chomp
+            head = git_spawn('rev-parse --abbrev-ref HEAD').chomp
             if head.empty?
               ret = 0
             else
@@ -1211,8 +1235,8 @@ module Squared
                 if (r1 = r[1]) && r1 =~ /^(.+):(?: ([a-z]+) (\d+),)? ([a-z]+) (\d+)$/
                   write = ->(s1, s2) { "#{s1.capitalize.rjust(7)}: #{sub_style(s2, styles: theme[:warn])}" }
                   r1 = $1
-                  r2 = $2 && write.($2, $3)
-                  r3 = write.($4, $5)
+                  r2 = $2 && write.call($2, $3)
+                  r3 = write.call($4, $5)
                 end
                 r1 = nil if r1 == "origin/#{data[0]}"
                 [" Branch: #{a + (r1 ? " (#{r1})" : '')}", r2, r3, " Commit: #{b}", "Message: #{r[2]}"]
@@ -1232,9 +1256,9 @@ module Squared
         end
 
         def restore(flag, opts = [])
-          opts = git_session('restore', "--#{flag}", opts: opts).last
-          refs = option_sanitize(opts, OPT_GIT[:restore], no: OPT_GIT[:no][:restore]).first
-          append_pathspec(refs, pass: false)
+          cmd, opts = git_session('restore', "--#{flag}", opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:restore], cmd, project: self, no: OPT_GIT[:no][:restore])
+          append_pathspec(op.extras, pass: false)
           source(sync: false, stderr: true)
         end
 
@@ -1264,13 +1288,14 @@ module Squared
               end
             end
           end
-          refs = option_sanitize(opts, OPT_GIT[:show] + OPT_GIT[:diff][:show] + OPT_GIT[:log][:diff],
-                                 no: OPT_GIT[:no][:show] + collect_hash(OPT_GIT[:no][:log], pass: [:base])).first
-          unless val == 'oneline' && session_arg?('abbrev-commit')
-            cmd << basic_option('abbrev', val) if (val = option('abbrev')) && val.to_i > 0
+          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]))
+          unless val == 'oneline' && op.arg?('abbrev-commit')
+            op << basic_option('abbrev', val) if (val = option('abbrev')) && val.to_i > 0
             banner = true
           end
-          append_value(refs, delim: true)
+          op.append(delim: true)
           source(exception: false, banner: banner)
         end
 
@@ -1289,60 +1314,60 @@ module Squared
             cmd << '--abbrev-ref'
             append_commit(ref, head: true)
           else
-            args = option_sanitize(opts, OPT_GIT[:rev_parse][flag]).first
-            append_value(args, escape: session_arg?('sq-quote'))
+            op = OptionPartition.new(opts, OPT_GIT[:rev_parse][flag], cmd, project: self)
+            op.append(escape: op.arg?('sq-quote'))
           end
-          source(banner: verbosity > 0)
+          source(banner: verbosetype > 1)
         end
 
         def ls_remote(flag, opts = [], remote: nil)
           cmd, opts = git_session('ls-remote', '--refs', opts: opts)
           cmd << "--#{flag}" unless flag == :remote
-          grep = option_sanitize(opts, OPT_GIT[:ls_remote]).first
-          cmd << shell_quote(remote) if remote
+          op = OptionPartition.new(opts, OPT_GIT[:ls_remote], cmd, project: self)
+          op << shell_quote(remote) if remote
           out, banner, from = source(io: true)
           print_item banner
-          ret = write_lines(out, grep: grep)
-          list_result(ret, flag.to_s, from: from, grep: grep)
+          ret = write_lines(out, grep: op.extras)
+          list_result(ret, flag.to_s, from: from, grep: op.extras)
         end
 
         def ls_files(flag, opts = [])
-          opts = git_session('ls-files', "--#{flag}", opts: opts).last
-          grep = option_sanitize(opts, OPT_GIT[:ls_files]).first
+          cmd, opts = git_session('ls-files', "--#{flag}", opts: opts)
+          op = OptionPartition.new(opts, OPT_GIT[:ls_files], cmd, project: self)
           out, banner, from = source(io: true)
           print_item banner
-          ret = write_lines(out, grep: grep)
-          list_result(ret, 'files', from: from, grep: grep)
+          ret = write_lines(out, grep: op.extras)
+          list_result(ret, 'files', from: from, grep: op.extras)
         end
 
         def git(flag, opts = [])
           cmd, opts = git_session(flag, opts: opts)
-          refs = option_sanitize(opts, OPT_GIT[flag], no: OPT_GIT[:no][flag]).first
+          op = OptionPartition.new(opts, OPT_GIT[flag], cmd, project: self, no: OPT_GIT[:no][flag])
           sync = false
           stderr = true
           case flag
           when :clean
-            refs = projectmap(refs)
+            refs = projectmap(op.extras)
             unless refs.empty?
-              cmd << '--'
-              cmd.merge(refs)
+              op << '--'
+              op.merge(refs)
             end
             sync = true
             stderr = false
           when :revert
-            if VAL_GIT[:rebase][:send].any? { |val| session_arg?(val) }
-              option_clear refs
-            elsif refs.empty?
+            if VAL_GIT[:rebase][:send].any? { |val| op.arg?(val) }
+              op.clear
+            elsif op.empty?
               raise_error 'no commit given'
             else
-              append_commit(*refs)
+              append_commit(*op.extras)
             end
           when :mv
-            refs = projectmap(refs)
+            refs = projectmap(op.extras)
             raise_error 'no source/destination' unless refs.size > 1
-            cmd.merge(refs)
+            op.merge(refs)
           when :rm
-            append_pathspec(refs, expect: true)
+            append_pathspec(op.extras, expect: true)
           end
           source(sync: sync, stderr: stderr)
         end
@@ -1379,8 +1404,11 @@ module Squared
                      format_banner((banner.is_a?(String) ? banner : cmd).gsub(File.join(path, ''), ''), banner: true)
                    end
           begin
-            return [stdout ? `#{cmd}` : IO.popen(cmd), banner, from] if io
+            if io
+              return `#{cmd}` if stdout
 
+              return banner ? [IO.popen(cmd), banner, from] : IO.popen(cmd)
+            end
             if stdin? ? sync : stdout
               print_item banner unless multiple
               ret = `#{cmd}`
@@ -1469,19 +1497,35 @@ module Squared
           on :last, from
         end
 
-        def status_digest(*args, algorithm: Digest::SHA256, **kwargs)
+        def choice_refs(msg, type, format: nil, sort: '-creatordate', count: ARG[:CHOICE], short: true, **kwargs)
+          unless format
+            format = +"%(refname#{short ? ':short' : ''})"
+            case type
+            when 'heads', 'tags'
+              format += '%(if)%(HEAD)%(then) *%(end)'
+              trim = /\s+\*\z/
+            end
+          end
+          cmd = git_output 'for-each-ref', quote_option('format', format)
+          cmd << quote_option('sort', sort) if sort
+          cmd << shell_option('count', count) if count
+          cmd << "refs/#{type}"
+          choice_index(msg, source(cmd, io: true, banner: false), trim: trim, **kwargs)
+        end
+
+        def status_digest(*args, algorithm: nil, **kwargs)
+          require 'digest'
+          algorithm ||= Digest::SHA256
           glob = kwargs.fetch(:include, [])
           pass = kwargs.fetch(:exclude, [])
           ret = {}
-          git_spawn('status -s --porcelain', *args, stdout: false)
-            .first
-            .each do |line|
-              next unless (file = line[/^[A-Z ?!]{3}"?(.+?)"?$/, 1])
-              next if !glob.empty? && glob.none? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
-              next if !pass.empty? && pass.any? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
-
-              ret[file] = algorithm.hexdigest(File.read(basepath(file)))
-            end
+          git_spawn('status -s --porcelain', *args, stdout: false).each do |line|
+            next unless (file = line[/^[A-Z ?!]{3}"?(.+?)"?$/, 1])
+            next if !glob.empty? && glob.none? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
+            next if !pass.empty? && pass.any? { |val| File.fnmatch?(val, file, File::FNM_DOTMATCH) }
+
+            ret[file] = algorithm.hexdigest(File.read(basepath(file)))
+          end
           ret
         end
 
@@ -1489,43 +1533,46 @@ module Squared
           source(git_output(*cmd), io: true, banner: false, stdout: stdout)
         end
 
-        def append_pull(opts, list, target: @session, no: nil, flag: nil, remote: nil)
-          cmd << '--force' if option('force')
-          rsm = append_submodules(target: target)
-          out = []
+        def append_pull(opts, list, target: @session, flag: nil, no: nil, remote: nil)
+          target << '--force' if option('force', target: target)
+          append_submodules(target: target)
+          return if !remote && opts.empty?
+
           refspec = []
-          opts, pat = option_sanitize(opts, remote ? list + ['refspec=b'] : list, target: target, no: no)
-          opts.each do |opt|
-            if opt =~ pat
+          op = OptionPartition.new(opts, remote ? list + ['refspec=v'] : list, target, project: self, no: no)
+          op.each do |opt|
+            if opt =~ op.values
               case $1
               when 'rebase'
-                target << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
+                op << basic_option($1, $2) if VAL_GIT[:rebase][:value].include?($2)
               when 'shallow-since'
                 next unless (val = Date.parse($2))
 
-                target << quote_option($1, val.strftime('%F %T'))
+                op << quote_option($1, val.strftime('%F %T'))
               when 'recurse-submodules'
-                target << basic_option($1, $2) unless rsm
+                op << basic_option($1, $2) unless op.arg?('recurse-submodules')
               when 'refspec'
                 refspec << shell_escape($2, quote: true)
               end
+            elsif op.arg?('--multiple')
+              op.found << opt
             else
-              out << opt
+              op.errors << opt
             end
           end
           if remote
-            append_value(remote, target: target, delim: true)
-            if (val = option('refspec', strict: true))
-              append_value(split_escape(val), target: target)
+            op.append(remote, delim: true)
+            if (val = option('refspec', target: target, strict: true))
+              op.append(*split_escape(val))
             else
-              target.merge(refspec)
+              op.merge(refspec)
             end
-            target.delete('--all')
-          elsif target.include?('--multiple')
-            target.merge(out.map! { |opt| shell_escape(opt, quote: true) })
+            op.delete('--all')
+          elsif op.arg?('--multiple')
+            op.swap.merge(op.map! { |opt| shell_escape(opt, quote: true) })
             return
           end
-          option_clear(out, target: target, subject: flag.to_s) if flag
+          op.clear(errors: true, subject: flag.to_s) if flag
         end
 
         def append_commit(*val, target: @session, head: false)
@@ -1538,10 +1585,10 @@ module Squared
         end
 
         def append_pathspec(files = [], target: @session, expect: false, parent: false, pass: true)
-          if session_arg?('pathspec-from-file')
+          if session_arg?('pathspec-from-file', target: target)
             option_clear files
           else
-            if files.empty? && (val = option('pathspec'))
+            if files.empty? && (val = option('pathspec', target: target))
               files = split_escape(val)
             end
             files = projectmap(files, parent: parent, pass: pass)
@@ -1564,7 +1611,7 @@ module Squared
         end
 
         def append_submodules(from = nil, target: @session)
-          return unless (val = option('recurse-submodules', ignore: false))
+          return unless (val = option('recurse-submodules', target: target, ignore: false))
 
           if from == :clone
             projectmap(split_escape(val)).each do |path|
@@ -1573,7 +1620,7 @@ module Squared
             target
           else
             target << case val
-                      when 'no', '0'
+                      when 'no', '0', 'false'
                         '--no-recurse-submodules'
                       when 'yes', 'on-demand'
                         "--recurse-submodules#{from == :reset ? '' : "=#{val}"}"
@@ -1587,9 +1634,9 @@ module Squared
           dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
           return session('git', *dir, *cmd, **kwargs) unless opts
 
-          opts = option_sanitize(opts, OPT_GIT[:common], target: dir).first
-          ret = session('git', *dir, *cmd, **kwargs)
-          [ret, opts]
+          op = OptionPartition.new(opts, OPT_GIT[:common], dir, project: self)
+          ret = session('git', *op.to_a, *cmd, **kwargs)
+          [ret, op.extras]
         end
 
         def git_output(*cmd, **kwargs)
@@ -1597,24 +1644,15 @@ module Squared
         end
 
         def dryrun?(*, target: @session, **)
-          !!target&.include?('--dry-run')
+          return false unless target
+
+          target.include?('--dry-run')
         end
 
         def quiet?(target: @session)
           return false unless target
 
-          target.include?('--quiet') || (target.include?('-q') && target.first == 'git')
-        end
-
-        def verbosity
-          case verbose
-          when true
-            0
-          when Numeric
-            verbose
-          else
-            -1
-          end
+          target.include?('--quiet') || (target.include?('-q') && stripext(target.first) == 'git')
         end
 
         def gitpath