squared 0.0.12 → 0.1.1

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

@@ -4,37 +4,36 @@ module Squared
   module Workspace
     module Project
       class Git < Base
-        OPT_PULL = %w[all tags prune ff-only autostash dry-run].freeze
-        OPT_FETCH = %w[tags prune prune-tags depth=n dry-run].freeze
+        OPT_PULL = %w[all ff-only autostash prune tags depth=n since=d jobs=n dry-run].freeze
+        OPT_FETCH = %w[prune-tags].concat(OPT_PULL[3..-1]).freeze
         private_constant :OPT_PULL, :OPT_FETCH
 
         class << self
-          include ::Rake::DSL
+          include Rake::DSL
 
           def populate(ws, **)
             return if ws.series[:pull].empty?
 
-            name = ws.task_name('all')
-            desc ws.task_name('all[git?=rebase|stash]', desc: true)
-            task name, [:git] do |_, args|
-              sync = lambda do |key|
-                key = ws.task_name(key)
-                ws.task_defined?(ret = ws.task_join(key, 'sync')) ? ret : key
+            namespace(name = ws.task_name('git')) do
+              all = ws.task_join(name, 'all')
+
+              desc ws.task_name("#{all}[git?=rebase|stash,depend?]", desc: true)
+              task 'all', [:git, :depend] do |_, args|
+                cmd = case args.git
+                      when 'rebase'
+                        [ws.task_sync('rebase')]
+                      when 'stash'
+                        [ws.task_sync('stash'), ws.task_sync('pull')]
+                      else
+                        [ws.task_sync('pull')]
+                      end
+                cmd << ws.task_sync('depend') if args.depend && !ws.series[:depend].empty?
+                cmd << ws.task_sync('build')
+                Common::Utils.task_invoke(*cmd, **ws.invokeargs)
               end
-              cmd = [case args.git
-                     when 'rebase'
-                       sync.('rebase')
-                     when 'stash'
-                       invoke(sync.('stash'), **ws.invokeargs)
-                       sync.('pull')
-                     else
-                       sync.('pull')
-                     end]
-              cmd << ws.task_name('build')
-              Common::Utils.task_invoke(*cmd, **ws.invokeargs)
+              ws.series.sync << all
+              ws.series.multiple << all
             end
-            ws.series.sync << name
-            ws.series.multiple << name
           end
 
           def tasks
@@ -63,7 +62,8 @@ module Squared
           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
+          rev: %i[commit branch].freeze,
+          show: %i[oneline pretty format].freeze
         }.freeze
 
         def initialize(*, **)
@@ -200,6 +200,21 @@ module Squared
                         reset(flag, ref: args.ref)
                       end
                     end
+                  when :show
+                    if flag == :oneline
+                      desc format_desc(action, flag, 'object*')
+                      task flag, [:object] do |_, args|
+                        objs = args.to_a
+                        show(objs, pretty: 'oneline', abbrev: true)
+                      end
+                    else
+                      desc format_desc(action, flag, 'format,object*')
+                      task flag, [:format, :object] do |_, args|
+                        format = guard_params(action, flag, args: args, key: :format)
+                        objs = args.to_a[1..-1] || []
+                        show(objs, "#{flag}": format)
+                      end
+                    end
                   end
                 end
               end
@@ -220,7 +235,13 @@ module Squared
             cmd << '--commit'
           end
           append_pull opts, OPT_PULL, flag
-          source(sync: sync, **threadargs)
+          sub = if verbose
+                  [
+                    { pat: /^(.+)(\|\s+\d+\s+)([^-]*)(-+)(.*)$/, styles: :red, index: 4 },
+                    { pat: /^(.+)(\|\s+\d+\s+)(\++)(-*)(.*)$/, styles: :green, index: 3 }
+                  ]
+                end
+          source(sync: sync, sub: sub, **threadargs)
         end
 
         def rebase
@@ -399,17 +420,34 @@ module Squared
                        raise_error('commit', 'pathspec', hint: 'missing') if (files = projectmap(files)).empty?
                        "-- #{files.join(' ')}"
                      end
-          unless push?
-            source('git branch -vv --list', io: true, banner: false).first.each do |val|
-              origin = %r{^\* [^\[]+(?<= )\[([\w.-/]+?)/([\w.-]+)\] }.match(val)
-              next unless origin
-
-              @origin = origin[1]
-              @branch = origin[2]
-              break
+          origin = nil
+          branch = nil
+          upstream = false
+          source('git fetch --no-tags --quiet', io: true, banner: false)
+          source('git branch -vv --list', io: true, banner: false).first.each do |val|
+            next unless (data = /^\*\s(\S+)\s+(\h+)(?:\s\[(.+?)(?=\]\s)\])?\s/.match(val))
+
+            branch = data[1]
+            sha = data[2]
+            if !data[3]
+              unless (origin = option('repository', prefix: 'git', ignore: false))
+                out = source('git log -n1 --format=%h%d', io: true, stdout: true, banner: false).first
+                if (data = /^#{sha} \(HEAD -> #{Regexp.escape(branch)}, (.+?)\)$/m.match(out))
+                  split_escape(data[1]).each do |val|
+                    next unless val.end_with?("/#{branch}")
+
+                    origin = val[0..val.size - branch.size - 2]
+                    break
+                  end
+                end
+              end
+              upstream = !origin.nil?
+            elsif (data = Regexp.new("^(.+)/#{Regexp.escape(branch)}$").match(data[3]))
+              origin = data[1]
             end
+            break
           end
-          raise_error('commit', 'work tree is not usable') unless push?
+          raise_error('commit', 'work tree is not usable') unless origin && branch
           cmd = git_session 'commit'
           cmd << '--dry-run' if option('dry-run')
           if amend
@@ -424,6 +462,7 @@ module Squared
           end
           a = ['git add --verbose']
           b = ['git push']
+          b << '--set-upstream' if upstream
           if dry_run?
             a << '--dry-run'
             b << '--dry-run'
@@ -433,7 +472,7 @@ module Squared
           b << @origin << @branch
           puts if pass
           source a.join(' ')
-          source
+          source cmd
           source b.join(' ')
         end
 
@@ -444,16 +483,38 @@ module Squared
           source(stdout: true)
         end
 
+        def show(objs, pretty: nil, format: nil, abbrev: nil)
+          cmd = git_session 'show'
+          case (flag = pretty&.downcase)
+          when 'oneline', 'short', 'medium', 'full', 'fuller', 'reference', 'email', 'raw'
+            cmd << "--pretty=#{flag}"
+          else
+            if pretty
+              cmd << "--pretty=#{shell_escape("tformat:#{pretty}", quote: true)}"
+            elsif format
+              cmd << "--format=#{shell_escape(format, quote: true)}"
+            end
+          end
+          if (abbrev ||= option('abbrev')) == true
+            cmd << '--abbrev-commit'
+          elsif abbrev.to_i > 0
+            cmd << "--abbrev=#{abbrev}"
+          end
+          append_value objs
+          source(exception: false)
+        end
+
         private
 
-        def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true)
+        def source(cmd = @session, exception: true, io: false, sync: true, stdout: false, stderr: false, banner: true,
+                   sub: nil)
           cmd = session_done(cmd)
           log.info cmd
           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)}")
+          cmd = cmd.sub(/^git\b/, "git --work-tree=#{shell_quote(path)} --git-dir=#{shell_quote(gitpath)}")
           begin
             if io
-              [IO.popen(cmd), banner]
+              [stdout ? `#{cmd}` : IO.popen(cmd), banner]
             elsif stdin? ? sync : stdout
               print_item banner
               ret = `#{cmd}`
@@ -469,11 +530,12 @@ module Squared
               require 'open3'
               if stderr
                 Open3.popen3(cmd) do |_, out, err|
-                  ret = write_lines(out, banner: banner, pass: true)
+                  ret = write_lines(out, banner: banner, sub: sub, pass: true)
                   if ret == 0
-                    write_lines(err, banner: banner)
+                    ret = write_lines(err, banner: banner)
+                    puts 'Success' if ret == 0 && banner && !stdin?
                   else
-                    write_lines(err, loglevel: ::Logger::DEBUG)
+                    write_lines(err, loglevel: Logger::DEBUG)
                   end
                 end
               else
@@ -484,15 +546,15 @@ module Squared
             log.error e
             raise if exception
 
-            warn log_message(::Logger::WARN, e) if warning?
+            warn log_message(Logger::WARN, e) if warning?
           end
         end
 
         def write_lines(data, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
-          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(::String)
+          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(String)
           sub = nil if stdin?
           ret = 0
-          lines = []
+          out = []
           data.each do |line|
             next if grep && !line.match?(grep)
 
@@ -501,14 +563,14 @@ module Squared
             else
               sub&.each { |h| line = sub_style(line, **h) }
               if banner
-                lines << line
+                out << line
               else
                 puts line
               end
             end
             ret += 1
           end
-          print_item banner, lines if banner && (ret > 0 || !pass)
+          print_item banner, out if banner && (ret > 0 || !pass)
           ret
         end
 
@@ -528,10 +590,10 @@ module Squared
         def append_pull(opts, list, flag = nil)
           append_submodules flag
           opts.each do |opt|
-            if list.include?(opt)
+            if list.include?(opt) || opt.match(/^(?:depth|jobs)=\d+$/)
               @session << "--#{opt}"
-            elsif opt.match(/^depth=(\d+)$/)
-              @session << "--depth=#{$1}"
+            elsif opt.match(/^since=(.+)$/) && (val = Date.parse($1))
+              @session << "--shallow-since=\"#{val.strftime('%F %T')}\""
             end
           end
         end
@@ -554,7 +616,7 @@ module Squared
         end
 
         def append_message(val)
-          @session << "--message \"#{double_quote(val)}\"" if val
+          @session << "--message=\"#{double_quote(val)}\"" if val
         end
 
         def append_head
@@ -577,26 +639,18 @@ module Squared
           end
         end
 
-        def append_option(list)
-          list.each { |val| @session << "--#{val}" if option(val) }
-        end
-
         def git_session(*cmd)
           session('git', *cmd)
         end
 
-        def gitpath
-          basepath('.git')
-        end
-
-        def push?
-          !@origin.nil? && !@branch.nil?
-        end
-
         def dry_run?
           @session.include?('--dry-run')
         end
 
+        def gitpath
+          basepath('.git')
+        end
+
         def threadargs
           { stderr: true, exception: exception || !workspace.series.multiple? }
         end