squared 0.4.6 → 0.4.7

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
@@ -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,
@@ -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(*, **)
@@ -391,7 +388,7 @@ module Squared
                         refs = param_guard(action, flag, args: args.to_a)
                         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)
@@ -699,17 +696,18 @@ 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 << '--autostash' if option('autostash')
+            cmd << '--rebase'
           elsif (val = option('rebase', ignore: false))
             cmd << case val
-                   when '0'
+                   when '0', 'false'
                      '--no-rebase'
                    else
                      VAL_GIT[:rebase][:value].include?(val) ? basic_option('rebase', val) : '--rebase'
                    end
           end
+          cmd << '--autostash' if option('autostash')
           append_pull(opts, OPT_GIT[:pull] + OPT_GIT[:fetch][:pull],
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
           source(sync: sync, sub: if verbose
@@ -727,15 +725,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
@@ -754,10 +752,10 @@ module Squared
 
         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 +784,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
@@ -864,13 +862,14 @@ module Squared
           sha = git_spawn('rev-parse --verify HEAD').first.to_s.chomp
           return if sha.empty?
 
-          args = []
           kwargs = kwargs.key?(:include) || kwargs.key?(:exclude) ? statusargs.() : @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 +903,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 +922,6 @@ module Squared
             end
           when :patch
             cmd << '--patch'
-          else
-            return
           end
           unless ref == false
             append_commit(ref, head: true)
@@ -952,13 +950,13 @@ module Squared
           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 +965,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 +980,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'
@@ -999,55 +997,56 @@ module Squared
 
         def logx(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)
@@ -1122,10 +1121,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 +1140,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)
@@ -1182,14 +1181,16 @@ 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)
@@ -1232,9 +1233,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 +1265,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 +1291,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
@@ -1473,15 +1475,13 @@ module Squared
           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).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
           ret
         end
 
@@ -1489,43 +1489,44 @@ 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)
           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 +1539,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 +1565,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 +1574,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 +1588,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 +1598,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