squared 0.0.10 → 0.0.12

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

@@ -12,58 +12,63 @@ module Squared
           include ::Rake::DSL
 
           def populate(ws, **)
-            return if ws.series.pull.empty?
+            return if ws.series[:pull].empty?
 
+            name = ws.task_name('all')
             desc ws.task_name('all[git?=rebase|stash]', desc: true)
-            task ws.task_name('all'), [:git] do |_, args|
+            task name, [:git] do |_, args|
               sync = lambda do |key|
                 key = ws.task_name(key)
-                ws.task_defined?(ret = "#{key}:sync") ? ret : key
+                ws.task_defined?(ret = ws.task_join(key, 'sync')) ? ret : key
               end
               cmd = [case args.git
                      when 'rebase'
                        sync.('rebase')
                      when 'stash'
-                       invoke(sync.('stash'), exception: ws.exception, warning: ws.warning)
+                       invoke(sync.('stash'), **ws.invokeargs)
                        sync.('pull')
                      else
                        sync.('pull')
                      end]
-              cmd << ws.task_name(ws.dev?(global: true) && ws.series.some?(:refresh) ? 'refresh' : 'build')
-              Common::Task.invoke(cmd, exception: ws.exception, warning: ws.warning)
+              cmd << ws.task_name('build')
+              Common::Utils.task_invoke(*cmd, **ws.invokeargs)
             end
+            ws.series.sync << name
+            ws.series.multiple << name
           end
 
           def tasks
             %i[pull rebase fetch stash status].freeze
           end
 
-          def is_a?(val)
-            if (val = as_path(val))
-              val.join('.git').directory?
-            else
-              super
-            end
+          def batchargs
+            [ref, { 'pull-s': %i[stash pull], 'rebase-s': %i[stash rebase] }]
+          end
+
+          def config?(val)
+            return false unless (val = as_path(val))
+
+            val.join('.git').directory?
           end
         end
 
         @@tasks[ref] = {
-          checkout: %i[branch detach force merge],
-          commit: %i[add amend amend-orig all no-all],
-          diff: %i[head cached branch files],
-          fetch: %i[all submodules unshallow],
-          files: %i[cached modified deleted others],
-          pull: %i[head rebase no-rebase commit no-commit submodules],
-          stash: %i[push pop apply list clear],
-          refs: %i[heads tags],
-          reset: %i[head soft mixed hard merge keep submodules],
-          restore: %i[worktree staged overlay],
-          rev: %i[commit branch]
+          checkout: %i[branch detach force merge].freeze,
+          commit: %i[add amend amend-orig all no-all].freeze,
+          diff: %i[head cached branch files].freeze,
+          fetch: %i[all submodules unshallow].freeze,
+          files: %i[cached modified deleted others].freeze,
+          pull: %i[head rebase no-rebase commit no-commit submodules].freeze,
+          stash: %i[push pop apply list clear].freeze,
+          refs: %i[heads tags].freeze,
+          reset: %i[head soft mixed hard merge keep submodules].freeze,
+          restore: %i[worktree staged overlay].freeze,
+          rev: %i[commit branch].freeze
         }.freeze
 
         def initialize(*, **)
           super
-          initialize_ref(Git.ref) if gitdir.exist?
+          initialize_ref(Git.ref) if gitpath.exist?
         end
 
         def ref
@@ -93,8 +98,7 @@ module Squared
                     else
                       desc format_desc(action, flag, 'pathspec+')
                       task flag, [:pathspec] do |_, args|
-                        files = args.to_a
-                        guard_params(action, flag, args: files)
+                        files = guard_params(action, flag, args: args.to_a)
                         __send__(action, flag, files)
                       end
                     end
@@ -126,11 +130,7 @@ module Squared
                       desc format_desc(action, flag, 'index?=0,pathspec*')
                       task flag, [:pathspec] do |_, args|
                         files = args.to_a
-                        diff(flag, files, index: if /^\d+$/.match?(files.first) && !git_option('index')
-                                                   files.shift.to_i
-                                                 else
-                                                   0
-                                                 end)
+                        diff(flag, files, index: /^\d+$/.match?(files[0]) && !option('index') ? files.shift.to_i : 0)
                       end
                     when :cached
                       desc format_desc(action, flag, 'pathspec*')
@@ -140,15 +140,15 @@ module Squared
                     when :branch
                       desc format_desc(action, flag, 'name,pathspec*')
                       task flag, [:name, :pathspec] do |_, args|
-                        guard_params(action, flag, args: args, key: :name)
-                        diff(flag, args.to_a[1..-1], branch: args.name)
+                        branch = guard_params(action, flag, args: args, key: :name)
+                        diff(flag, args.to_a[1..-1] || [], branch: branch)
                       end
                     when :files
                       desc format_desc(action, flag, 'path1,path2')
                       task flag, [:path1, :path2] do |_, args|
-                        guard_params(action, flag, args: args, key: :path1)
-                        guard_params(action, flag, args: args, key: :path2)
-                        diff(flag, [args.path1, args.path2])
+                        path1 = guard_params(action, flag, args: args, key: :path1)
+                        path2 = guard_params(action, flag, args: args, key: :path2)
+                        diff(flag, [path1, path2])
                       end
                     end
                   when :checkout
@@ -156,7 +156,7 @@ module Squared
                     when :branch
                       desc format_desc(action, flag, 'name,create?=b|B,commit?,detach?=d')
                       task flag, [:name, :create, :commit, :detach] do |_, args|
-                        guard_params(action, flag, args: args, key: :name)
+                        branch = guard_params(action, flag, args: args, key: :name)
                         create = args.create
                         if args.commit == 'd'
                           detach = 'd'
@@ -174,7 +174,7 @@ module Squared
                           commit = args.commit
                         end
                         guard_params(action, flag, args: { create: create }, key: :create, pat: /^b$/i) if create
-                        checkout(flag, branch: args.name, create: create, commit: commit, detach: detach)
+                        checkout(flag, branch: branch, create: create, commit: commit, detach: detach)
                       end
                     when :detach
                       desc format_desc(action, flag, 'branch/commit?')
@@ -189,10 +189,9 @@ module Squared
                     end
                   when :reset
                     if flag == :head
-                      desc format_desc(action, flag, 'ref?=HEAD,pathspec+')
+                      desc format_desc(action, flag, 'ref,pathspec+')
                       task flag, [:ref, :pathspec] do |_, args|
-                        files = args.to_a[1..-1]
-                        guard_params(action, flag, args: files)
+                        files = guard_params(action, flag, args: args.to_a[1..-1] || [])
                         reset(flag, files, ref: args.ref)
                       end
                     else
@@ -210,18 +209,18 @@ module Squared
 
         def pull(flag = nil, sync: invoked_sync?('pull', flag), opts: [])
           cmd = git_session 'pull'
-          if flag == :'no-rebase'
+          if flag == :'no-rebase' || option('rebase', equals: '0')
             cmd << '--no-rebase'
-          elsif flag == :rebase || git_option('rebase')
+          elsif flag == :rebase || option('rebase')
             cmd << '--rebase'
           end
-          if flag == :'no-commit'
+          if flag == :'no-commit' || option('commit', equals: '0')
             cmd << '--no-commit'
-          elsif flag == :commit || git_option('commit')
+          elsif flag == :commit || option('commit')
             cmd << '--commit'
           end
           append_pull opts, OPT_PULL, flag
-          source(sync: sync, **gitthread)
+          source(sync: sync, **threadargs)
         end
 
         def rebase
@@ -230,28 +229,28 @@ module Squared
 
         def fetch(flag = nil, opts: [])
           cmd = git_session 'fetch'
-          cmd << '--all' if flag == :all || git_option('all')
+          cmd << '--all' if flag == :all || option('all')
           append_pull opts, OPT_FETCH, flag
-          source(sync: invoked_sync?('fetch', flag), **gitthread)
+          source(sync: invoked_sync?('fetch', flag), **threadargs)
         end
 
         def stash(flag = nil, files = [], commit: nil)
-          cmd = git_session 'stash', (flag || 'push').to_s
+          cmd = git_session 'stash', flag || 'push'
           case flag
           when :apply, :pop
-            cmd << '--index' if git_option('index')
+            cmd << '--index' if option('index')
             cmd << commit
           else
             append_option %w[all staged include-untracked].freeze
-            append_message git_option('message', 'm', zero: false)
+            append_message option('message', 'm', ignore: false)
             append_pathspec files
           end
-          source(sync: invoked_sync?('stash', flag), **gitthread)
+          source(sync: invoked_sync?('stash', flag), **threadargs)
         end
 
         def status
-          cmd = git_session 'status', git_option('long') ? '--long' : '--short'
-          if (val = git_option('ignore-submodules'))
+          cmd = git_session 'status', option('long') ? '--long' : '--short'
+          if (val = option('ignore-submodules', ignore: false))
             cmd << "--ignore-submodules=#{case val
                                           when '0', 'none'
                                             'none'
@@ -269,15 +268,15 @@ module Squared
             print_item banner
             banner = nil
           end
-          sub = if verbose
-                  [
-                    { pat: /^(.)([A-Z])(.+)$/, styles: :red, index: 2 },
-                    { pat: /^([A-Z])(.+)$/, styles: :green },
-                    { pat: /^(\?\?)(.+)$/, styles: :red },
-                    { pat: /^(## )(.+)(\.{3})(.+)$/, styles: [nil, :green, nil, :red], index: -1 }
-                  ]
-                end
-          ret = write_lines(out, banner: banner, sub: sub)
+          ret = write_lines(out, banner: banner, sub: if verbose
+                                                        [
+                                                          { pat: /^(.)([A-Z])(.+)$/, styles: :red, index: 2 },
+                                                          { pat: /^([A-Z])(.+)$/, styles: :green },
+                                                          { pat: /^(\?\?)(.+)$/, styles: :red },
+                                                          { pat: /^(## )(.+)(\.{3})(.+)$/,
+                                                            styles: [nil, :green, nil, :red], index: -1 }
+                                                        ]
+                                                      end)
           list_result(ret, 'files', action: 'modified')
         end
 
@@ -294,7 +293,7 @@ module Squared
               append_submodules flag
             else
               cmd << '--mixed'
-              cmd << '--no-refresh' if git_option('refresh', equals: '0')
+              cmd << '--no-refresh' if option('refresh', equals: '0')
             end
             append_commit ref
           end
@@ -305,10 +304,10 @@ module Squared
           cmd = git_session 'checkout'
           case flag
           when :branch
-            cmd << '--detach' if detach == 'd' || git_option('detach')
+            cmd << '--detach' if detach == 'd' || option('detach')
             if create
               cmd << "-#{create}" << branch
-              if (val = git_option('start-point'))
+              if (val = option('start-point'))
                 cmd << val
               end
             else
@@ -362,32 +361,32 @@ module Squared
               sha = nil
             end
           end
-          if (val = git_option('unified')).to_i > 0
+          if (val = option('unified')).to_i > 0
             cmd << "--unified=#{val}"
           end
           append_nocolor
           case flag
           when :cached
             cmd << '--cached'
-            cmd << '--merge-base' if git_option('merge-base')
+            cmd << '--merge-base' if option('merge-base')
           when :branch
             cmd << branch
           when :files
             cmd << '--no-index'
           else
-            if (val = git_option('index')) || index > 0
+            if (val = option('index')) || index > 0
               cmd << "HEAD~#{val || index}"
-            elsif sha && git_option('merge-base')
+            elsif sha && option('merge-base')
               cmd << '--merge-base'
             end
           end
           cmd << sha
-          append_pathspec(files, pass: flag == :files)
+          append_pathspec(files, parent: flag == :files)
           source(exception: cmd.include?('--exit-code'))
         end
 
         def commit(flag, files = [], message: nil, pass: false)
-          message ||= git_option('message', 'm', zero: false)
+          message ||= option('message', 'm', prefix: 'git', ignore: false)
           amend = flag.to_s.start_with?('amend')
           if !message && !amend
             return if pass
@@ -397,8 +396,7 @@ module Squared
           pathspec = if flag == :all || (amend && files.size == 1 && files.first == '*')
                        '--all'
                      else
-                       files = source_path(as_a(files))
-                       raise_error('commit', 'pathspec', hint: 'missing') if files.empty?
+                       raise_error('commit', 'pathspec', hint: 'missing') if (files = projectmap(files)).empty?
                        "-- #{files.join(' ')}"
                      end
           unless push?
@@ -413,7 +411,7 @@ module Squared
           end
           raise_error('commit', 'work tree is not usable') unless push?
           cmd = git_session 'commit'
-          cmd << '--dry-run' if git_option('dry-run')
+          cmd << '--dry-run' if option('dry-run')
           if amend
             cmd << '--amend'
           else
@@ -421,7 +419,7 @@ module Squared
           end
           if message
             append_message message
-          elsif flag == :'amend-orig' || git_option('no-edit')
+          elsif flag == :'amend-orig' || option('no-edit')
             cmd << '--no-edit'
           end
           a = ['git add --verbose']
@@ -448,11 +446,11 @@ module Squared
 
         private
 
-        def source(cmd = @session, exception: true, banner: true, io: false, sync: true, stdout: false, stderr: false)
-          cmd = close_session(cmd)
+        def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true)
+          cmd = session_done(cmd)
           log.info cmd
-          banner = format_banner(cmd.gsub(File.join(path, ''), ''), banner: banner, multiple: true)
-          cmd = cmd.sub(/^git\b/, "git --work-tree #{shell_quote(path)} --git-dir #{shell_quote(gitdir)}")
+          banner = format_banner(cmd.gsub(File.join(path, ''), ''), banner: banner)
+          cmd = cmd.sub(/^git\b/, "git --work-tree #{shell_quote(path)} --git-dir #{shell_quote(gitpath)}")
           begin
             if io
               [IO.popen(cmd), banner]
@@ -527,11 +525,6 @@ module Squared
           end
         end
 
-        def source_path(files, pass: false)
-          files = files.select { |val| source_path?(val) } unless pass
-          files.map { |val| val == '.' ? '.' : shell_quote(base_path(val.strip)) }
-        end
-
         def append_pull(opts, list, flag = nil)
           append_submodules flag
           opts.each do |opt|
@@ -545,18 +538,18 @@ module Squared
 
         def append_commit(val)
           val = val.to_s.strip
-          val.empty? ? 'HEAD' : val
+          @session << (val.empty? ? 'HEAD' : val)
         end
 
-        def append_pathspec(files = [], expect: false, pass: false)
-          if files.empty? && (val = git_option('pathspec'))
+        def append_pathspec(files = [], expect: false, parent: false)
+          if files.empty? && (val = option('pathspec'))
             files = split_escape(val)
           end
-          files = source_path(files, pass: pass)
+          files = projectmap(files, parent: parent)
           if !files.empty?
             @session << "-- #{files.join(' ')}"
           elsif expect
-            raise_error(pass ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
+            raise_error(parent ? 'pathspec not present' : 'pathspec not within worktree', hint: 'invalid')
           end
         end
 
@@ -565,50 +558,35 @@ module Squared
         end
 
         def append_head
-          @session << (git_option('head') || git_option('tree-ish'))
+          @session << (option('head') || option('tree-ish'))
         end
 
         def append_ours
-          if git_option('ours')
+          if option('ours')
             @session << '--ours'
-          elsif git_option('theirs')
+          elsif option('theirs')
             @session << '--theirs'
           end
         end
 
         def append_submodules(flag = nil)
-          if git_option('recurse-submodules', equals: '0')
+          if option('recurse-submodules', equals: '0')
             @session << '--no-recurse-submodules'
-          elsif flag == :submodules || git_option('recurse-submodules')
+          elsif flag == :submodules || option('recurse-submodules')
             @session << '--recurse-submodules'
           end
         end
 
         def append_option(list)
-          list.each { |val| @session << "--#{val}" if git_option(val) }
-        end
-
-        def git_option(*args, equals: nil, zero: true)
-          for val in args
-            break if (ret = ENV["GIT_#{val.gsub(/\W/, '_').upcase}"])
-          end
-          if !equals.nil?
-            ret == equals.to_s
-          elsif !ret.nil? && !ret.empty? && !(ret == '0' && zero)
-            ret
-          end
+          list.each { |val| @session << "--#{val}" if option(val) }
         end
 
         def git_session(*cmd)
           session('git', *cmd)
         end
 
-        def gitthread
-          { stderr: true, exception: !workspace.series.multiple? }
-        end
-
-        def gitdir
-          base_path('.git')
+        def gitpath
+          basepath('.git')
         end
 
         def push?
@@ -618,7 +596,13 @@ module Squared
         def dry_run?
           @session.include?('--dry-run')
         end
+
+        def threadargs
+          { stderr: true, exception: exception || !workspace.series.multiple? }
+        end
       end
+
+      Application.implement Git
     end
   end
 end