squared 0.3.6 → 0.4.1

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require 'date'
+require 'time'
+require 'digest'
+
 module Squared
   module Workspace
     module Git
@@ -7,7 +11,9 @@ module Squared
       GIT_PROTO = %r{^(?:https?|ssh|git|file)://}i.freeze
       private_constant :GIT_REPO, :GIT_PROTO
 
-      def git(name, uri = nil, base: nil, repo: [], options: {})
+      attr_reader :revfile
+
+      def git(name, uri = nil, base: nil, repo: [], options: {}, cache: nil)
         data = {}
         check = ->(proj) { proj.is_a?(Project::Git) && !proj.exclude?(Project::Git.ref) && git_clone?(proj.path) }
         if uri.is_a?(Array)
@@ -17,15 +23,15 @@ module Squared
           data[name.to_s] = uri
         elsif name.is_a?(Enumerable)
           data = name.to_h
-        elsif name.is_a?(String) && name =~ GIT_PROTO
+        elsif name.is_a?(String) && name.match?(GIT_PROTO)
           base = name
           @project.each_value { |proj| repo << proj if !proj.parent && check.(proj) }
         else
-          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid') if warning
+          warn log_message(Logger::WARN, name, subject: 'git', hint: 'invalid', pass: true) if warning
           return self
         end
         if base
-          base = base =~ GIT_PROTO ? "#{base.chomp('/')}/" : @root.join(base)
+          base = base.match?(GIT_PROTO) ? "#{base.chomp('/')}/" : @root.join(base)
           repo.each do |target|
             if target.is_a?(Project::Git)
               data[target.localname] = target.project
@@ -55,6 +61,23 @@ module Squared
           (GIT_REPO[main] ||= {})[key] = [uri.to_s, opts]
           (@kind[key] ||= []) << Project::Git
         end
+        if cache == true
+          revbuild
+        elsif cache
+          revbuild(file: cache)
+        end
+        self
+      end
+
+      def revbuild(file: nil)
+        @revfile = @home.join(file || "#{@main}.revb")
+        @revdoc = JSON.parse(@revfile.read) if @revfile.exist?
+      rescue StandardError => e
+        @revfile = nil
+        warn log_message(Logger::WARN, e, pass: true) if @warning
+        self
+      else
+        @revdoc = {} unless @revdoc.is_a?(Hash)
         self
       end
 
@@ -62,11 +85,61 @@ module Squared
         (ret = GIT_REPO[main]) && ret[name]
       end
 
+      def rev_entry(*keys, val: nil, create: true)
+        return unless @revdoc
+        return @revdoc.dig(*keys) unless val
+
+        data = @revdoc
+        last = keys.pop
+        for key in keys
+          if data[key].is_a?(Hash)
+            data = data[key]
+          elsif create
+            data = data[key] = {}
+          else
+            return
+          end
+        end
+        data[last] = val
+      end
+
+      def rev_timeutc(*keys)
+        rev_entry(*keys, val: rev_timenow)
+      end
+
+      def rev_timesince(*keys, clock: false)
+        epoch = rev_timenow - rev_entry(*keys).to_i
+      rescue StandardError
+        nil
+      else
+        time_format(epoch, clock: clock)
+      end
+
+      def rev_clear(name)
+        rev_write if rev_entry(name, 'revision', val: '', create: false)
+      end
+
+      def rev_write(name = nil, data = nil, utc: nil)
+        return unless @revfile
+
+        if name
+          data&.each { |key, val| rev_entry(name, key, val: val) }
+          rev_timeutc(name, utc) if utc
+        end
+        File.write(@revfile, JSON.pretty_generate(@revdoc))
+      end
+
       def git_clone?(path, name = nil)
         return false if name && !git_repo(name)
 
         !path.exist? || path.empty?
       end
+
+      private
+
+      def rev_timenow
+        DateTime.now.strftime('%Q').to_i + time_offset
+      end
     end
     Application.include Git
 
@@ -75,12 +148,15 @@ module Squared
         include Prompt
 
         OPT_GIT = {
+          common: %w[bare p|paginate P|no-pager glob-pathspecs icase-pathspecs literal-pathspecs no-optional-locks
+                     no-replace-objects noglob-pathspecs c=q config-env=q exec-path=p namespace=p].freeze,
           branch: %w[a|all create-reflog i|ignore-case q|quiet r|remotes v|verbose abbrev=i color=b column=b
-                     contains=e format=q merged=e no-contains=e no-merged=e points-at=e u|set-upstream-to=e sort=q
+                     contains=b format=q merged=b no-contains=b no-merged=b points-at=e u|set-upstream-to=e sort=q
                      t|track=b].freeze,
           checkout: %w[l d|detach f|force ignore-other-worktrees ignore-skip-worktree-bits m|merge p|patch
                        pathspec-file-nul q quiet orphan=e ours theirs conflict=b pathspec-from-file=p
                        t|track=b].freeze,
+          clean: %w[d x X f|force i|interactive n|dry-run q|quiet e|exlcude=q].freeze,
           diff: {
             base: %w[0 1|base 2|ours 3|theirs].freeze,
             show: %w[s exit-code histogram].freeze
@@ -90,7 +166,7 @@ module Squared
                      recurse-submodules-default=b].freeze,
             pull: %w[4 6 n t a|append atomic dry-run f|force k|keep n|negotiate-only prefetch p|prune q|quiet
                      set-upstream unshallow update-shallow v|verbose deepen=i depth=i j|jobs=i negotiation-tip=q
-                     refmap=q o|server-option=e shallow-exclude=e shallow-since=b upload-pack=e].freeze
+                     refmap=q o|server-option=q shallow-exclude=e shallow-since=b upload-pack=q].freeze
           }.freeze,
           log: {
             base: %w[all all-match alternate-refs author-date-order basic-regexp bisect boundary cherry cherry-mark
@@ -98,7 +174,7 @@ module Squared
                      first-parent F|fixed-strings follow full-diff full-history ignore-missing invert-grep left-only
                      merge log-size no-max-parents no-min-parents not P|perl-regexp reflog i|regexp-ignore-case
                      remove-empty reverse right-only simplify-by-decoration simplify-merges single-worktree show-pulls
-                     source sparse stdin topo-order g|walk-reflogs after=q ancestry-path=e? author=q before=q
+                     source sparse stdin topo-order g|walk-reflogs after=q ancestry-path=b? author=q before=q
                      branches=q? committer=q decorate=b decorate-refs=q decorate-refs-exclude=q exclude=q
                      exclude-hidden=b? glob=q grep=q grep-reflog=q L=q n|max-count=i max-parents=i min-parents=i
                      no-walk=b? remotes=q? since=q since-as-filter=q skip=i tags=q? until=q].freeze,
@@ -109,9 +185,9 @@ module Squared
                      W|function-context w|ignore-all-space ignore-blank-lines ignore-cr-at-eol ignore-space-at-eol
                      b|ignore-space-change D|irreversible-delete graph ita-invisible-in-index minimal name-only
                      name-status no-color-moved-ws no-prefix no-renames numstat patch-with-raw patch-with-stat patience
-                     pickaxe-all pickaxe-regex raw shortstat summary a|text abbrev=i? anchored=q B|break-rewrites=e?
+                     pickaxe-all pickaxe-regex raw shortstat summary a|text abbrev=i? anchored=q B|break-rewrites=b?
                      color=b color-moved=b color-moved-ws=b color-words=q? diff-algorithm=b diff-filter=e? X|dirstat=q?
-                     dirstat-by-file=q? dst-prefix=q C|find-copies=i? find-object=e M|find-renames=i?
+                     dirstat-by-file=q? dst-prefix=q C|find-copies=i? find-object=b M|find-renames=i?
                      I|ignore-matching-lines=q ignore-submodules=b inter-hunk-context=i line-prefix=q output=p
                      output-indicator-context=q output-indicator-new=q output-indicator-old=q relative=p rotate-to=p
                      skip-to=p src-prefix=q stat=q? stat-width=i stat-name-width=i stat-count=i submodule=b? U|unified=i
@@ -120,25 +196,32 @@ module Squared
           ls_files: %w[z debug deduplicate directory eol error-unmatch exclude-standard full-name k|killed
                        no-empty-directory recurse-submodules sparse s|stage u|unmerged abbrev=i x|exclude=q
                        X|exclude-from=p exclude-per-directory=p format=q with-tree=q].freeze,
-          ls_remote: %w[exit-code get-url q|quiet o|server-option=e symref sort=q upload-pack=e].freeze,
-          pull: %w[e n allow-unrelated-histories ff-only S|gpg-sign=e log=i r|rebase=b? s|strategy=b
-                   X|strategy-option=e].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
+                   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,
           rebase: %w[n C=i allow-empty-message apply committer-date-is-author-date edit-todo f|force-rebase ignore-date
                      ignore-whitespace i|interactive keep-base m merge no-ff q|quiet quit r|rebase-merges=b?
-                     reset-author-date root show-current-patch signoff v|verbose empty=b S|gpg-sign=b onto=e
-                     s|strategy=b X|strategy-option=b whitespace=e].freeze,
+                     reset-author-date root show-current-patch signoff v|verbose empty=b S|gpg-sign=qq onto=e
+                     s|strategy=b X|strategy-option=b whitespace=b].freeze,
           reset: %w[N pathspec-file-nul q|quiet pathspec-from-file=p].freeze,
           restore: %w[ignore-unmerged ignore-skip-worktree-bits m|merge ours p|patch pathspec-file-nul S|staged theirs
                       W|worktree conflict=b pathspec-from-file=p s|source=q].freeze,
+          revert: %w[e abort continue no-commit quit reference skip cleanup=b S|gpg-sign=qq m|mainline=i s|signoff
+                     strategy=b X|strategy-option=b].freeze,
           rev_parse: {
             output: %w[absolute-git-dir all flags git-common-dir git-dir is-bare-repository is-inside-git-dir
                        is-inside-work-tree is-shallow-repository local-env-vars no-flags no-revs not q|quiet sq
                        revs-only shared-index-path show-cdup show-prefix show-toplevel show-superproject-working-tree
-                       sq-quote symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q default=e
+                       sq-quote symbolic symbolic-full-name verify abbrev-ref=b? after=q before=q default=q
                        disambiguate=b exclude=q exclude-hidden=b glob=q git-path=p path-format=b? prefix=q branches=q?
                        remotes=q? resolve-git-dir=p short=i? show-object-format=b? since=q tags=q? until=q].freeze,
             parseopt: %w[keep-dashdash stop-at-non-option stuck-long].freeze
           }.freeze,
+          rm: %w[r cached f|force n|dry-run ignore-unmatch pathspec-file-nul q|quiet sparse v|verbose
+                 pathspec-from-file=p].freeze,
           show: %w[t combined-all-paths no-diff-merges remerge-diff show-signature diff-merges=b encoding=b
                    expand-tabs=i notes=q show-notes=q?].freeze,
           stash: {
@@ -148,7 +231,8 @@ module Squared
             pop: %w[index].freeze,
             apply: %w[index].freeze
           }.freeze,
-          tag: %w[create-reflog column=b contains=e? format=q merged=e? n=i no-contains=e? no-merged=e? points-at=q
+          status: %w[untracked-files=b? u|ignore-submodules=m? ignored=b?],
+          tag: %w[create-reflog column=b contains=b? format=q merged=b? n=i no-contains=b? no-merged=b? points-at=q
                   sort=q].freeze,
           no: {
             fetch: {
@@ -164,20 +248,26 @@ module Squared
             tag: %w[column].freeze,
             branch: %w[color-moved column color track].freeze,
             checkout: %w[overwrite-ignore guess overlay progress recurse-submodules track].freeze,
+            merge: %w[autostash edit ff gpg-sign log progress overwrite-ignore rerere-autoupdate signoff squash stat
+                      verify verify-signatures].freeze,
             rebase: %w[autosquash autostash fork-point gpg-sign keep-empty reapply-cherry-picks reschedule-failed-exec
                        rerere-autoupdate stat update-refs verify].freeze,
             reset: %w[refresh].freeze,
             restore: %w[overlay progress recurse-submodules].freeze,
+            revert: %w[edit gpg-sign rerere-autoupdate].freeze,
             show: %w[standard-notes].freeze
           }.freeze
-        }
+        }.freeze
         VAL_GIT = {
+          merge: {
+            send: %w[continue abort quit].freeze
+          }.freeze,
           rebase: {
             send: %w[continue skip abort quit].freeze,
             value: %w[true false merges interactive].freeze
           }.freeze,
           reset: %w[soft mixed hard merge keep recurse-submodules no-recurse-submodules].freeze
-        }
+        }.freeze
         private_constant :OPT_GIT, :VAL_GIT
 
         class << self
@@ -209,11 +299,7 @@ module Squared
           end
 
           def tasks
-            %i[pull rebase fetch clone stash status].freeze
-          end
-
-          def batchargs
-            [ref, { 'pull+s': %i[stash pull], 'rebase+s': %i[stash rebase] }]
+            %i[pull rebase fetch clone stash status branch revbuild].freeze
           end
 
           def config?(val)
@@ -227,24 +313,25 @@ module Squared
           'branch' => %i[create set delete move copy list edit current].freeze,
           'checkout' => %i[commit branch track detach path].freeze,
           'commit' => %i[add all amend amend-orig].freeze,
-          'diff' => %i[head cached branch files view between contain].freeze,
+          'diff' => %i[head branch files view between contain].freeze,
           'fetch' => %i[origin remote].freeze,
           'files' => %i[cached modified deleted others ignored].freeze,
+          'git' => %i[clean mv restore revert rm].freeze,
           'log' => %i[view between contain].freeze,
+          'merge' => %i[commit no-commit send].freeze,
           'pull' => %i[origin remote].freeze,
           'rebase' => %i[branch onto send].freeze,
           'refs' => %i[heads tags remote].freeze,
           'reset' => %i[commit index patch mode].freeze,
-          'restore' => %i[source worktree staged overlay].freeze,
-          'rev' => %i[commit branch output parseopt].freeze,
-          'show' => %i[format oneline].freeze,
+          '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
         }.freeze
 
         def initialize(*, **)
           super
-          initialize_ref(Git.ref) if gitpath.exist?
+          initialize_ref Git.ref if gitpath.exist?
         end
 
         def ref
@@ -289,19 +376,6 @@ module Squared
                         commit(flag, refs: refs)
                       end
                     end
-                  when 'restore'
-                    if flag == :source
-                      format_desc action, flag, 'tree,opts*,pathspec*'
-                      task flag, [:tree] do |_, args|
-                        tree = param_guard(action, flag, args: args, key: :tree)
-                        restore(flag, args.extras, tree: tree)
-                      end
-                    else
-                      format_desc action, flag, 'opts*,pathspec+'
-                      task flag do |_, args|
-                        restore flag, args.to_a
-                      end
-                    end
                   when 'tag'
                     case flag
                     when :list
@@ -335,9 +409,19 @@ module Squared
                     case flag
                     when :view, :between, :contain
                       if flag == :view && action == 'log'
-                        format_desc action, flag, '(^)commit*,pathspec*,opts*'
+                        format_desc action, flag, '(^)commit/H0*,pathspec*,opts*'
                         task flag do |_, args|
-                          logx flag, args.to_a
+                          index = []
+                          args.to_a.each do |val|
+                            if val =~ /^H(\d+)$/
+                              index << "HEAD~#{$1}"
+                            elsif (sha = commithash(val))
+                              index << sha
+                            elsif val.start_with?('^') || (!%r{^[.\\/]}.match?(val) && !%r{[\\/]$}.match?(val))
+                              index << shell_quote(val)
+                            end
+                          end
+                          logx(flag, args.to_a.drop(index.size), index: index)
                         end
                       else
                         format_desc action, flag, 'commit1,commit2,pathspec*,opts*'
@@ -347,10 +431,16 @@ module Squared
                           __send__(action == 'log' ? :logx : :diff, flag, args.extras, range: [commit1, commit2])
                         end
                       end
-                    when :head, :cached
-                      format_desc action, flag, 'opts*,pathspec*'
+                    when :head
+                      format_desc action, flag, 'commit/H0*,opts*,pathspec*'
                       task flag do |_, args|
-                        diff flag, args.to_a
+                        index = []
+                        args.to_a.each do |val|
+                          break unless val =~ /^H(\d+)$/ || (sha = commithash(val))
+
+                          index << ($1 ? "HEAD~#{$1}" : sha)
+                        end
+                        diff(flag, args.to_a.drop(index.size), index: index)
                       end
                     when :branch
                       format_desc action, flag, 'name,opts*,pathspec*'
@@ -487,15 +577,21 @@ module Squared
                     when :oneline
                       format_desc action, flag, 'opts*,object*'
                       task flag do |_, args|
-                        show 'oneline', args.to_a.push('abbrev-commit')
+                        show flag, args.to_a.push('abbrev-commit')
                       end
                     when :format
                       format_desc action, flag, 'format?,opts*,object*'
                       task flag, [:format] do |_, args|
-                        show args.format, args.extras
+                        show(flag, args.extras, format: args.format)
+                      end
+                    when :textconv
+                      format_desc action, flag, 'files+'
+                      task flag do |_, args|
+                        files = param_guard(action, flag, args: args.to_a)
+                        show(flag, files: files)
                       end
                     end
-                  when 'rebase'
+                  when 'rebase', 'merge'
                     case flag
                     when :branch
                       format_desc action, flag, 'opts*,upstream?,branch?'
@@ -510,11 +606,18 @@ module Squared
                         upstream = param_guard(action, flag, args: args, key: :upstream)
                         rebase(flag, commit: commit, upstream: upstream, branch: args.branch)
                       end
+                    when :commit, :'no-commit'
+                      format_desc action, flag, 'branch/commit+,opts*'
+                      task flag do |_, args|
+                        args = param_guard(action, flag, args: args.to_a)
+                        merge flag, args
+                      end
                     when :send
-                      format_desc(action, flag, VAL_GIT[:rebase][:send], arg: nil)
+                      format_desc(action, flag, VAL_GIT[action.to_sym][:send], arg: nil)
                       task flag, [:command] do |_, args|
-                        command = param_guard(action, flag, args: args, key: :command)
-                        rebase(flag, command: command)
+                        command = param_guard(action, flag, args: args, key: :command,
+                                                            values: VAL_GIT[action.to_sym][:send])
+                        __send__(action, flag, command: command)
                       end
                     end
                   when 'rev'
@@ -535,6 +638,11 @@ module Squared
                       task flag, [:ref] do |_, args|
                         rev_parse(flag, ref: args.ref)
                       end
+                    when :build
+                      format_desc action, flag, OPT_GIT[:status]
+                      task flag do |_, args|
+                        revbuild flag, args.to_a
+                      end
                     else
                       format_desc action, flag, 'opts*,args*'
                       task flag do |_, args|
@@ -554,6 +662,18 @@ module Squared
                         __send__(action == 'refs' ? :ls_remote : :ls_files, flag, args.to_a)
                       end
                     end
+                  when 'git'
+                    format_desc(action, flag, 'opts*', before: case flag
+                                                               when :rm
+                                                                 'source+,destination'
+                                                               when :revert
+                                                                 'commit+'
+                                                               else
+                                                                 'pathspec*'
+                                                               end)
+                    task flag do |_, args|
+                      git(flag, args.to_a)
+                    end
                   end
                 end
               end
@@ -566,8 +686,18 @@ module Squared
           super
         end
 
+        def depend(*, **)
+          workspace.rev_clear name
+          super
+        end
+
+        def clean(*, **)
+          workspace.rev_clear name
+          super
+        end
+
         def pull(flag = nil, opts = [], sync: invoked_sync?('pull', flag), remote: nil)
-          cmd = git_session 'pull', flag && "--#{flag}"
+          cmd, opts = git_session('pull', flag && "--#{flag}", opts: opts)
           if (val = option('rebase', ignore: false))
             cmd << case val
                    when '0'
@@ -580,8 +710,8 @@ module Squared
                       no: OPT_GIT[:no][:pull] + OPT_GIT[:no][:fetch][:pull], remote: remote, flag: flag)
           source(sync: sync, sub: if verbose
                                     [
-                                      { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: :red, index: 4 },
-                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: :green, index: 3 }
+                                      { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: color(:red), index: 4 },
+                                      { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: color(:green), index: 3 }
                                     ]
                                   end, **threadargs)
         end
@@ -590,7 +720,7 @@ module Squared
                    command: nil)
           return pull(:rebase, sync: sync) unless flag
 
-          cmd = git_session 'rebase'
+          cmd, opts = git_session('rebase', opts: opts)
           case flag
           when :branch
             branch = option_sanitize(opts, OPT_GIT[:rebase], no: OPT_GIT[:no][:rebase]).first
@@ -619,7 +749,7 @@ module Squared
         end
 
         def fetch(flag = nil, opts = [], sync: invoked_sync?('fetch', flag), remote: nil)
-          cmd = git_session 'fetch'
+          cmd, opts = git_session('fetch', opts: opts)
           cmd << '--all' if !remote && !opts.include?('multiple') && option('all')
           cmd << '--verbose' if verbose && !opts.include?('quiet')
           append_pull(opts, collect_hash(OPT_GIT[:fetch]), no: collect_hash(OPT_GIT[:no][:fetch]),
@@ -651,9 +781,8 @@ module Squared
 
         def stash(flag = nil, opts = [], sync: invoked_sync?('stash', flag))
           if flag
-            cmd = git_session 'stash', flag
-            list = OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])
-            refs = option_sanitize(opts, list).first
+            cmd, opts = git_session('stash', flag, opts: opts)
+            refs = option_sanitize(opts, OPT_GIT[:stash][:common] + OPT_GIT[:stash].fetch(flag, [])).first
             case flag
             when :push
               append_pathspec refs
@@ -675,14 +804,14 @@ module Squared
               return
             end
           else
-            git_session 'stash', 'push'
+            git_session('stash', 'push', opts: opts)
             append_option(%w[all keep-index include-untracked staged].freeze, no: true, ignore: false)
             append_message option('message', 'm', ignore: false)
           end
           source(banner: !quiet?, sync: sync, **threadargs)
         end
 
-        def status(*, sync: invoked_sync?('status'), **)
+        def status(*)
           cmd = git_session 'status'
           cmd << (option('long') ? '--long' : '--short')
           if (val = option('ignore-submodules', ignore: false))
@@ -699,24 +828,76 @@ module Squared
           end
           append_pathspec
           out, banner, from = source(io: true)
-          if sync
-            print_item banner
-            banner = nil
-          end
           ret = write_lines(out, banner: banner, sub: if verbose
+                                                        r = color(:red)
+                                                        g = color(:green)
                                                         [
-                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: :red, index: 2 },
-                                                          { pat: /^([A-Z?!])(.+)$/, styles: :green },
-                                                          { pat: /^(\?\?)(.+)$/, styles: :red },
+                                                          { pat: /^(.)([A-Z?!])(.+)$/, styles: r, index: 2 },
+                                                          { pat: /^([A-Z?!])(.+)$/, styles: g },
+                                                          { pat: /^(\?\?)(.+)$/, styles: r },
                                                           { pat: /^(## )(.+)(\.{3})(.+)$/,
-                                                            styles: [nil, :green, nil, :red], index: -1 }
+                                                            styles: [nil, g, nil, r], index: -1 }
                                                         ]
                                                       end)
           list_result(ret, 'files', from: from, action: 'modified')
         end
 
+        def revbuild(flag = nil, opts = [], sync: invoked_sync?('revbuild', flag), **kwargs)
+          statusargs = lambda do
+            {
+              include: relativepath(as_a(kwargs[:include]), all: true),
+              exclude: relativepath(as_a(kwargs[:exclude]), all: true)
+            }
+          end
+          unless workspace.closed
+            if @revbuild
+              statusargs.().each { |key, val| @revbuild[key] += val }
+            else
+              @revbuild = statusargs.()
+            end
+            return
+          end
+          sha = source(git_output('rev-parse --verify HEAD'), io: true, banner: false, stdout: true).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
+          else
+            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'))
+          end
+          if (cur = workspace.rev_entry(name)) && cur['revision'] == sha
+            files = status_digest(*args, **kwargs)
+            if cur['files'].size == files.size && cur['files'].find { |key, val| files[key] != val }.nil?
+              if verbose
+                if (since = workspace.rev_timesince(name, 'build'))
+                  puts log_message(Logger::INFO, name, 'no changes', subject: 'revbuild', hint: "#{since} ago")
+                else
+                  workspace.rev_timeutc(name, 'build')
+                end
+              end
+              return
+            end
+          end
+          start = epochtime
+          build(@output, sync: sync, from: :'git:revbuild')
+        rescue StandardError => e
+          warn log_message(Logger::WARN, e, pass: true) if warning?
+        else
+          if verbose
+            msg = sub_style('completed', styles: theme[:active])
+            puts log_message(Logger::INFO, name, msg, subject: 'revbuild', hint: time_format(epochtime - start))
+          end
+          workspace.rev_write(name, { 'revision' => sha, 'files' => status_digest(*args, **kwargs) }, utc: 'build')
+        end
+
         def reset(flag, opts = [], refs: nil, ref: nil, mode: nil, commit: nil)
-          cmd = git_session 'reset'
+          cmd, opts = git_session('reset', opts: opts)
           case flag
           when :commit, :index
             out = option_sanitize(opts, OPT_GIT[:reset] + VAL_GIT[:reset], no: OPT_GIT[:no][:reset]).first
@@ -741,21 +922,19 @@ module Squared
             return
           end
           unless ref == false
-            append_commit ref
+            append_commit(ref, head: true)
             append_pathspec refs if refs
           end
           source
         end
 
         def checkout(flag, opts = [], branch: nil, origin: nil, create: nil, commit: nil, detach: nil)
-          cmd = git_session 'checkout'
+          cmd, opts = git_session('checkout', opts: opts)
           append_option 'force', 'merge'
           case flag
           when :branch
             cmd << '--detach' if detach == 'd' || option('detach')
-            if (val = option('track'))
-              cmd << shell_option('track', val)
-            end
+            append_option('track', equals: true)
             cmd << if create
                      shell_option(create, branch)
                    else
@@ -787,7 +966,7 @@ module Squared
         end
 
         def tag(flag, opts = [], refs: [], message: nil, commit: nil)
-          cmd = git_session 'tag'
+          cmd, opts = git_session('tag', opts: opts)
           case flag
           when :add
             if option('sign')
@@ -795,8 +974,8 @@ module Squared
             elsif !session_arg?('s', 'sign', 'u', 'local-user')
               cmd << '--annotate'
             end
-            if !commit && message && (hash = commithash(message))
-              commit = hash
+            if !commit && message && (sha = commithash(message))
+              commit = sha
             else
               append_message message
             end
@@ -819,41 +998,27 @@ module Squared
           source
         end
 
-        def logx(flag, opts = [], range: [])
-          cmd = git_session 'log'
-          files = option_sanitize(opts, collect_hash(OPT_GIT[:log]), no: collect_hash(OPT_GIT[:no][:log])).first
+        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
           case flag
           when :between, :contain
             cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
           else
-            commit, files = files.partition do |val|
-              val.start_with?('^') || (!%r{^[.\\/]}.match?(val) && !%r{[\\/]$}.match?(val)) || commithash(val)
-            end
-            cmd.merge(commit.map { |val| commithash(val) || shell_quote(val) }) unless commit.empty?
+            cmd.merge(index)
           end
           append_nocolor
-          append_pathspec files
+          append_pathspec refs
           source(exception: false)
         end
 
-        def diff(flag, opts = [], refs: [], branch: nil, range: [])
-          cmd = git_session 'diff'
+        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
           case flag
           when :files, :view, :between, :contain
             cmd.delete('--cached')
-          else
-            items = files.dup
-            sha = nil
-            files.clear
-            items.each do |val|
-              if (s = commithash(val))
-                (sha ||= []).push(s)
-              else
-                files << val
-              end
-            end
           end
           append_nocolor
           if flag == :files
@@ -868,15 +1033,14 @@ module Squared
               cmd.delete('--merge-base')
               cmd << shell_quote(range.join(flag == :between ? '..' : '...'))
             else
-              cmd << '--cached' if flag == :cached
               cmd << '--merge-base' if option('merge-base')
               cmd << shell_quote(branch) if branch
-              if sha
+              if !index.empty?
                 if session_arg?('cached')
-                  raise_error('diff', sha.join(', '), hint: 'one commit') if sha.size > 1
-                  cmd << sha.first
+                  raise_error("one commit only: #{index.join(', ')}", hint: '--cached') if index.size > 1
+                  cmd << index.first
                 else
-                  cmd.merge(sha)
+                  cmd.merge(index)
                 end
               elsif (n = option('index'))
                 cmd << "HEAD~#{n}"
@@ -893,12 +1057,12 @@ module Squared
           if !message && !amend
             return if pass
 
-            raise_error('commit', 'GIT_MESSAGE="description"', hint: 'missing')
+            raise_error('missing message', hint: 'GIT_MESSAGE="description"')
           end
           pathspec = if flag == :all || (amend && refs.size == 1 && refs.first == '*')
                        '--all'
                      elsif (refs = projectmap(refs)).empty?
-                       raise_error('commit', 'pathspec', hint: 'missing')
+                       raise_error 'no qualified pathspec'
                      else
                        "-- #{refs.join(' ')}"
                      end
@@ -907,13 +1071,15 @@ module Squared
           upstream = nil
           source(git_output('fetch --no-tags --quiet'), io: true, banner: false)
           source(git_output('branch -vv --list'), io: true, banner: false).first.each do |val|
-            next unless (data = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
+            next unless (r = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
 
-            branch = data[1]
-            if !data[3]
+            branch = r[1]
+            if r[3]
+              origin = r[3][%r{^(.+)/#{Regexp.escape(branch)}$}, 1]
+            else
               unless (origin = option('repository', prefix: 'git', ignore: false))
-                out = source(git_output('log -n1 --format=%h%d'), io: true, stdout: true, banner: false).first
-                if out =~ /^#{data[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
+                out = source(git_output('log -n1 --format=%h%d'), io: true, banner: false, stdout: true).first
+                if out =~ /^#{r[2]} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/
                   split_escape($1).each do |val|
                     next unless val.end_with?("/#{branch}")
 
@@ -923,12 +1089,10 @@ module Squared
                 end
               end
               upstream = true if origin
-            elsif data[3] =~ %r{^(.+)/#{Regexp.escape(branch)}$}
-              origin = $1
             end
             break
           end
-          raise_error('commit', 'work tree is not usable') unless origin && branch
+          raise_error 'work tree is not usable' unless origin && branch
           cmd = git_session('commit', option('dry-run') && '--dry-run', options: false)
           if amend
             cmd << '--amend'
@@ -955,8 +1119,24 @@ module Squared
           source b
         end
 
-        def branch(flag, opts = [], refs: [], ref: nil, target: nil)
-          cmd = git_session 'branch'
+        def merge(flag, opts = [], command: nil)
+          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)
+          else
+            return unless VAL_GIT[:merge][:send].include?(command)
+
+            cmd << "--#{command}"
+          end
+          source
+        end
+
+        def branch(flag = nil, opts = [], refs: [], ref: nil, target: nil)
+          cmd, opts = git_session('branch', opts: opts)
           stdout = false
           case flag
           when :create
@@ -983,7 +1163,7 @@ module Squared
             end
             ref = nil
           when :delete
-            force, list = refs.partition { |val| val =~ /^[\^~]/ }
+            force, list = refs.partition { |val| val.match?(/^[\^~]/) }
             force.each do |val|
               dr = val[0, 3]
               d = dr.include?('^') ? '-D' : '-d'
@@ -1003,10 +1183,9 @@ module Squared
             cmd << '--edit-description'
           when :current
             cmd << '--show-current'
-          else
-            opts = option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch]).first
+          when :list
             grep = []
-            opts.each do |opt|
+            option_sanitize(opts, OPT_GIT[:branch], no: OPT_GIT[:no][:branch]).first.each do |opt|
               if opt =~ /^(v+)$/
                 cmd << "-#{$1}"
               else
@@ -1018,42 +1197,59 @@ module Squared
             out, banner, from = source(io: true)
             print_item banner
             ret = write_lines(out, sub: [
-              { pat: /^(\*\s+)(\S+)(\s*)$/, styles: :green, index: 2 },
-              { pat: %r{^(\s*)(remotes/\S+)(.*)$}, styles: :red, index: 2 }
+              { pat: /^(\*\s+)(\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 = source(git_output('rev-parse --abbrev-ref HEAD'), io: true, banner: false, stdout: true).first.chomp
+            if head.empty?
+              ret = 0
+            else
+              out, banner, from = source(cmd << '-vv --no-abbrev --list', io: true)
+              ret = write_lines(out, grep: /^\*\s+#{Regexp.escape(head)}\s/, banner: banner, first: true) do |line|
+                next line if stdin?
+
+                data = line.sub(/^\*\s+/, '').split(/\s+/)
+                a = sub_style(data[0], styles: theme[:inline])
+                b = sub_style(data[1], styles: theme[:extra])
+                r = /\A(?:\[(.+?)(?=\]\s)\]\s)?(.+)\z/m.match(data[2..-1].join(' '))
+                [" Branch: #{a + (r[1] ? " (#{r[1]})" : '')}", " Commit: #{b}", "Message: #{r[2]}"].compact.join("\n")
+              end
+              on :last, from
+            end
+            if ret == 0
+              warn log_message(Logger::WARN, name, 'no ref found', subject: 'branch', hint: 'head', pass: true)
+            end
+            return
           end
           cmd << shell_escape(target) if target
           cmd << shell_escape(ref) if ref
           source(stdout: stdout)
         end
 
-        def restore(flag, opts = [], tree: nil)
-          cmd = git_session 'restore'
-          refs = option_sanitize(opts, OPT_GIT[:restore], no: OPT_GIT[:no][:restore]).first
-          if flag == :source
-            cmd << '--patch' if refs.empty?
-            cmd << shell_option('source', tree)
-          else
-            cmd << "--#{flag}"
-          end
-          if session_arg?('p', 'patch')
-            option_clear refs
-          else
-            append_pathspec(refs, expect: true)
+        def show(flag, opts = [], format: nil, files: [])
+          cmd, opts = git_session('show', opts: opts)
+          case flag
+          when :textconv
+            cmd << '--textconv'
+            files = files.map { |val| Dir[val] }
+                         .flatten
+                         .select { |val| projectpath?(val) }
+                         .map { |val| shell_quote("HEAD:#{val}") }
+            append_value files
+            source(banner: false)
+            return
+          when :oneline
+            format = flag.to_s
           end
-          source(sync: false, stderr: true)
-        end
-
-        def show(format, opts = [])
-          cmd = git_session 'show'
           if format
             case (val = format.downcase)
             when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
               cmd << basic_option('format', val)
             else
-              if format =~ /^t?format:/ || format.include?('%')
+              if format.match?(/^t?format:/) || format.include?('%')
                 cmd << quote_option('pretty', format)
               else
                 opts << format
@@ -1071,18 +1267,19 @@ module Squared
         end
 
         def rev_parse(flag, opts = [], ref: nil, size: nil)
-          cmd = git_session 'rev-parse', if flag == :parseopt
-                                           '--parseopt'
-                                         elsif opts.delete('sq-quote')
-                                           '--sq-quote'
-                                         end
+          cmd, opts = git_session('rev-parse', opts: opts)
+          cmd << if flag == :parseopt
+                   '--parseopt'
+                 elsif opts.delete('sq-quote')
+                   '--sq-quote'
+                 end
           case flag
           when :commit
             cmd << ((n = size.to_i) > 0 ? basic_option('short', [n, 5].max) : '--verify')
-            append_commit ref
+            append_commit(ref, head: true)
           when :branch
             cmd << '--abbrev-ref'
-            append_commit 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'))
@@ -1091,7 +1288,7 @@ module Squared
         end
 
         def ls_remote(flag, opts = [], remote: nil)
-          cmd = git_session 'ls-remote', '--refs'
+          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
@@ -1102,7 +1299,7 @@ module Squared
         end
 
         def ls_files(flag, opts = [])
-          git_session 'ls-files', "--#{flag}"
+          opts = git_session('ls-files', "--#{flag}", opts: opts).last
           grep = option_sanitize(opts, OPT_GIT[:ls_files]).first
           out, banner, from = source(io: true)
           print_item banner
@@ -1110,10 +1307,51 @@ module Squared
           list_result(ret, 'files', from: from, grep: grep)
         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
+          refs = projectmap(refs) unless flag == :revert
+          sync = false
+          stderr = true
+          case flag
+          when :clean
+            unless refs.empty?
+              cmd << '--'
+              cmd.merge(refs)
+            end
+            sync = true
+            stderr = false
+          when :restore
+            if session_arg?('p', 'patch')
+              option_clear refs
+            else
+              append_pathspec(refs, expect: true)
+            end
+          when :revert
+            if VAL_GIT[:rebase][:send].any? { |val| session_arg?(val) }
+              option_clear refs
+            elsif refs.empty?
+              raise_error 'no commit given'
+            else
+              append_commit(*refs)
+            end
+          when :mv
+            raise_error 'no source/destination' unless refs.size > 1
+            cmd.merge(refs)
+          when :rm
+            append_pathspec(refs, expect: true)
+          end
+          source(sync: sync, stderr: stderr)
+        end
+
         def clone?
           ref?(workspace.baseref) && workspace.git_clone?(path, name) ? 1 : false
         end
 
+        def revbuild?
+          build? && !!workspace.revfile
+        end
+
         def enabled?(*, **kwargs)
           super || (kwargs[:base] == false && !!clone?)
         end
@@ -1126,7 +1364,7 @@ module Squared
           if cmd.respond_to?(:done)
             if io && banner == false
               from = nil
-            elsif !from && (from = cmd.drop(1).find { |val| val =~ /^[a-z][a-z\-]{2,}$/ })
+            elsif !from && (from = cmd.drop(1).find { |val| val.match?(/^[a-z][a-z\-]{2,}$/) })
               from = :"git:#{from}"
             end
             banner &&= cmd.temp { |val| val.start_with?('--work-tree') || val.start_with?('--git-dir') }
@@ -1172,13 +1410,13 @@ module Squared
             ret = on(:error, from, e)
             raise if exception && ret != true
 
-            warn log_message(Logger::WARN, e) if warning?
+            warn log_message(Logger::WARN, e, pass: true) if warning?
           else
             on :last, from
           end
         end
 
-        def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
+        def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false, first: false)
           grep = as_a(grep).map do |val|
             next val if val.is_a?(Regexp)
 
@@ -1191,6 +1429,7 @@ module Squared
           data.each do |line|
             next if grep&.none? { |pat| pat.match?(line) }
 
+            line = yield line if block_given?
             if loglevel
               log&.add loglevel, line
             else
@@ -1202,8 +1441,9 @@ module Squared
               end
             end
             ret += 1
+            break if first
           end
-          print_item banner, out if banner && (ret > 0 || !pass)
+          print_item banner, out if banner && (ret > 0 || (!pass && !first))
           ret
         end
 
@@ -1226,6 +1466,21 @@ module Squared
           on :last, from
         end
 
+        def status_digest(*args, algorithm: Digest::SHA256, **kwargs)
+          glob = kwargs.fetch(:include, [])
+          pass = kwargs.fetch(:exclude, [])
+          ret = {}
+          out = source(git_output('status -s --porcelain', *args), io: true, banner: false).first
+          out.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
+
         def append_pull(opts, list, target: @session, no: nil, flag: nil, remote: nil)
           cmd << '--force' if option('force')
           rsm = append_submodules(target: target)
@@ -1265,9 +1520,13 @@ module Squared
           option_clear(out, target: target, subject: flag.to_s) if flag
         end
 
-        def append_commit(val, target: @session)
-          val = val.to_s.strip
-          target << (val.empty? ? append_head(target: target) || 'HEAD' : val)
+        def append_commit(*val, target: @session, head: false)
+          val.compact!
+          if !val.empty?
+            val.each { |ref| target << (commithash(ref) || shell_quote(ref)) }
+          elsif head
+            target << (append_head(target: target) || 'HEAD')
+          end
         end
 
         def append_pathspec(files = [], target: @session, expect: false, parent: false)
@@ -1279,9 +1538,9 @@ module Squared
             end
             files = projectmap(files, parent: parent)
             if !files.empty?
-              target << "-- #{files.join(' ')}"
+              target << '--' << files.join(' ')
             elsif expect
-              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
+              raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree')
             end
           end
         end
@@ -1316,9 +1575,13 @@ module Squared
           end
         end
 
-        def git_session(*cmd, worktree: true, **kwargs)
+        def git_session(*cmd, opts: nil, worktree: true, **kwargs)
           dir = worktree ? ["--work-tree=#{shell_quote(path)}", "--git-dir=#{shell_quote(gitpath)}"] : []
-          session('git', *dir, *cmd, **kwargs)
+          ret = session('git', *dir, **kwargs)
+          return ret.merge(cmd) unless opts
+
+          opts = option_sanitize(opts, OPT_GIT[:common]).first
+          [ret.merge(cmd), opts]
         end
 
         def git_output(*cmd, **kwargs)
@@ -1336,11 +1599,11 @@ module Squared
         end
 
         def gitpath
-          basepath('.git')
+          basepath '.git'
         end
 
         def commithash(val)
-          val =~ /\A#\{(\h{5,40})\}\z/ ? $1 : nil
+          val[/^#\{(\h{5,40})\}$/, 1]
         end
 
         def threadargs