squared 0.0.1

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

@@ -0,0 +1,521 @@
+# frozen_string_literal: true
+
+module Squared
+  module Repo
+    module Project
+      class Git < Base
+        include Common::Format
+
+        class << self
+          def tasks
+            %i[pull rebase fetch stash status].freeze
+          end
+
+          def to_sym
+            :git
+          end
+
+          def is_a?(path)
+            if path.is_a?(::String) || path.is_a?(::Pathname)
+              Pathname.new(path).join('.git').directory?
+            else
+              super
+            end
+          end
+        end
+
+        @@tasks[:git] = {
+          checkout: %i[branch detach force merge],
+          commit: %i[add amend amend-orig all no-all],
+          diff: %i[head cached branch],
+          fetch: %i[all submodules unshallow],
+          files: %i[cached modified deleted others],
+          pull: %i[rebase no-rebase commit no-commit submodules],
+          stash: %i[push pop apply list clear],
+          refs: %i[heads tags],
+          reset: %i[hard mixed soft],
+          rev: %i[commit branch]
+        }.freeze
+
+        def populate(*)
+          super
+          return unless vardir.exist?
+
+          namespace @name do
+            @@tasks[:git].each do |action, flags|
+              namespace action do
+                flags.each do |flag|
+                  case action
+                  when :pull
+                    desc format_desc(action, flag, %w[all tags prune ff-only autostash dry-run])
+                    task flag, [:opts] do |_, args|
+                      opts = collect_args(args, :opts)
+                      pull(flag, opts: opts)
+                    end
+                  when :fetch
+                    desc format_desc(action, flag, %w[tags prune prune-tags depth=n dry-run])
+                    task flag, [:opts] do |_, args|
+                      opts = collect_args(args, :opts)
+                      fetch(flag, opts: opts)
+                    end
+                  when :commit
+                    if flag == :all
+                      desc format_desc(action, flag, 'message?')
+                      task flag, [:message] do |_, args|
+                        commit(:all, message: args.fetch(:message, nil))
+                      end
+                    else
+                      desc format_desc(action, flag, 'pathspec+')
+                      task flag, [:pathspec] do |_, args|
+                        guard_params(action, flag, args: args, key: :pathspec)
+                        commit(flag, collect_args(args, :pathspec))
+                      end
+                    end
+                  when :stash
+                    if flag == :push
+                      desc format_desc(action, flag, 'pathspec*')
+                      task :push, [:pathspec] do |_, args|
+                        stash(:push, collect_args(args, :pathspec))
+                      end
+                    else
+                      desc format_desc(action, flag, 'commit?')
+                      task flag, [:commit] do |_, args|
+                        stash(flag, commit: args.commit)
+                      end
+                    end
+                  when :rev
+                    desc format_desc(action, flag, "ref?=HEAD#{flag == :commit ? ',size?' : ''}")
+                    task flag, [:ref, :size] do |_, args|
+                      rev(flag, ref: args.ref, size: args.size)
+                    end
+                  when :refs, :files
+                    desc format_desc(action, flag, 'grep?=pattern')
+                    task flag, [:grep] do |_, args|
+                      send(action, flag, grep: args.fetch(:grep, nil))
+                    end
+                  when :diff
+                    case flag
+                    when :head
+                      desc format_desc(action, flag, 'index?=0,pathspec*')
+                      task flag, [:pathspec] do |_, args|
+                        files = collect_args(args, :pathspec)
+                        index = /^\d+$/.match?(files.first) && !option('index') ? files.shift.to_i : 0
+                        diff(:head, files, index: index)
+                      end
+                    when :cached
+                      desc format_desc(action, flag, 'pathspec*')
+                      task flag, [:pathspec] do |_, args|
+                        diff(:cached, collect_args(args, :pathspec))
+                      end
+                    when :branch
+                      desc format_desc(action, flag, 'name,pathspec*')
+                      task flag, [:name, :pathspec] do |_, args|
+                        guard_params(action, flag, args: args, key: :name)
+                        diff(:branch, collect_args(args, :pathspec), branch: args.name)
+                      end
+                    end
+                  when :checkout
+                    case flag
+                    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)
+                        create = args.create
+                        if args.commit == 'd'
+                          detach = 'd'
+                          commit = nil
+                        elsif create == 'd'
+                          create = nil
+                          commit = nil
+                          detach = 'd'
+                        elsif create && create.size > 1
+                          commit = create
+                          create = nil
+                          detach = args.commit
+                        else
+                          detach = args.detach
+                          commit = args.commit
+                        end
+                        guard_params('checkout', :branch, args: args, key: :create, pat: /^[Bb]$/) if create
+                        checkout(:branch, branch: args.name, create: create, commit: commit, detach: detach)
+                      end
+                    when :detach
+                      desc format_desc(action, flag, 'branch/commit?')
+                      task flag, [:commit] do |_, args|
+                        checkout(:detach, commit: args.commit)
+                      end
+                    else
+                      desc format_desc(action, flag, 'pathspec*')
+                      task flag, [:pathspec] do |_, args|
+                        checkout(flag, collect_args(args, :pathspec))
+                      end
+                    end
+                  when :reset
+                    desc format_desc(action, flag, 'commit')
+                    task flag, [:commit] do |_, args|
+                      guard_params(action, flag, args: args, key: :commit)
+                      reset(flag, commit: args.commit)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        def pull(flag = nil, sync: invoked_sync?('pull', flag), opts: [])
+          cmd = git_session 'pull'
+          if flag == :'no-rebase'
+            cmd << '--no-rebase'
+          elsif flag == :rebase || option('rebase')
+            cmd << '--rebase'
+          end
+          if flag == :'no-commit'
+            cmd << '--no-commit'
+          elsif flag == :commit || option('commit')
+            cmd << '--commit'
+          end
+          cmd << '--recurse-submodules' if flag == :submodules || option('recurse-submodules')
+          opts.each do |val|
+            case val
+            when 'all', 'tags', 'prune', 'ff-only', 'autostash', 'dry-run'
+              cmd << "--#{val}"
+            end
+          end
+          source(sync: sync, stderr: true, exception: !@workspace.multitask?)
+        end
+
+        def rebase
+          pull(:rebase, sync: invoked_sync?('rebase'))
+        end
+
+        def fetch(flag = nil, opts: [])
+          cmd = git_session 'fetch'
+          cmd << '--all' if flag == :all || option('all')
+          cmd << '--recurse-submodules' if flag == :submodules || option('recurse-submodules')
+          opts.each do |val|
+            case val
+            when 'tags', 'prune', 'prune-tags', 'dry-run'
+              cmd << "--#{val}"
+            else
+              cmd << "--depth=#{$1}" if /^depth=(\d+)$/.match(val)
+            end
+          end
+          source(sync: invoked_sync?('fetch', flag), stderr: true, exception: !@workspace.multitask?)
+        end
+
+        def stash(flag = :push, files = [], commit: nil)
+          cmd = git_session 'stash', flag.to_s
+          case flag
+          when :apply, :pop
+            cmd << '--index' if option('index')
+            cmd << commit if commit
+          else
+            %w[all staged include-untracked].each { |val| cmd << "--#{val}" if option(val) }
+            append_message option('message')
+            append_pathspec files
+          end
+          source(sync: invoked_sync?('stash', flag), exception: @workspace.exception)
+        end
+
+        def status
+          cmd = git_session 'status', option('long') ? '--long' : '--short'
+          if (val = option('ignore-submodules'))
+            cmd << "--ignore-submodules=#{case val
+                                          when '0', 'none'
+                                            'none'
+                                          when '1', 'untracked'
+                                            'untracked'
+                                          when '2', 'dirty'
+                                            'dirty'
+                                          else
+                                            'all'
+                                          end}"
+          end
+          if (val = option('pathspec'))
+            append_pathspec split_escape(val)
+          end
+          out, banner = source(io: true)
+          if banner && invoked_sync?('status')
+            print_item banner
+            banner = nil
+          end
+          ret = write_lines(out, banner: banner, sub: [
+            { pat: /^(.)([A-Z])(.+)$/, styles: :red, index: 2 },
+            { pat: /^([A-Z])(.+)$/, styles: :green },
+            { pat: /^(\?\?)(.+)$/, styles: :red },
+            { pat: /^(## )(.+)(\.{3})(.+)$/, styles: [nil, :green, nil, :red], index: -1 }
+          ])
+          list_result(ret, 'files', action: 'modified')
+        end
+
+        def reset(flag, commit: nil)
+          source "git reset --#{flag} #{commit}"
+        end
+
+        def checkout(flag, files = [], branch: nil, create: nil, commit: nil, detach: nil)
+          cmd = git_session 'checkout'
+          case flag
+          when :branch
+            cmd << '--detach' if detach == 'd' || option('detach')
+            if create
+              cmd << "-#{create} #{branch}"
+              if (val = option('start-point'))
+                cmd << val
+              end
+            else
+              cmd << branch
+            end
+            cmd << commit if commit
+          when :detach
+            cmd << "--#{flag}"
+            cmd << commit if commit
+          else
+            cmd << "--#{flag}"
+            if option('ours')
+              cmd << '--ours'
+            elsif option('theirs')
+              cmd << '--theirs'
+            end
+            if (val = option('tree-ish'))
+              cmd << val
+            end
+            append_pathspec files
+          end
+          source
+        end
+
+        def rev(flag, ref: nil, size: nil)
+          opt = if flag == :branch
+                  '--abbrev-ref'
+                else
+                  (n = size.to_i) > 0 ? "--short=#{[n, 5].max}" : '--verify'
+                end
+          git_session 'rev-parse', opt, ref || 'HEAD'
+          source
+        end
+
+        def refs(flag, grep: nil)
+          git_session 'ls-remote', " --#{flag}"
+          out, banner = source(io: true)
+          print_item banner
+          ret = write_lines(out, grep: grep)
+          list_result(ret, flag.to_s, grep: grep)
+        end
+
+        def files(flag, grep: nil)
+          git_session 'ls-files', " --#{flag}"
+          out, banner = source(io: true)
+          print_item banner
+          ret = write_lines(out, grep: grep)
+          list_result(ret, 'files', grep: grep)
+        end
+
+        def diff(flag, files = [], branch: nil, index: 0)
+          cmd = git_session 'diff'
+          if /^#[0-9a-f]{5,40}\#$/.match?(sha = files.first)
+            files.shift
+          else
+            sha = nil
+          end
+          if (val = option('unified')).to_i > 0
+            cmd << "--unified=#{val}"
+          end
+          append_nocolor
+          case flag
+          when :cached
+            cmd << '--cached'
+            cmd << '--merge-base' if option('merge-base')
+          when :branch
+            cmd << branch
+          else
+            if (val = option('index')) || index > 0
+              cmd << "HEAD~#{val || index}"
+            elsif sha && option('merge-base')
+              cmd << '--merge-base'
+            end
+          end
+          cmd << sha if sha
+          append_pathspec files
+          source
+        end
+
+        def commit(flag, files = [], message: nil, pass: false)
+          message = option('message') if message.nil?
+          amend = flag.to_s.start_with?('amend')
+          if !message && !amend
+            return if pass
+
+            raise ArgumentError, message('commit', 'GIT_MESSAGE="description"', hint: 'missing')
+          end
+          pathspec = if flag == :all || (amend && files.size == 1 && files.first == '*')
+                       '--all'
+                     else
+                       files = source_path(as_a(files))
+                       raise ArgumentError, message('commit', 'pathspec', hint: 'missing') if files.empty?
+
+                       "-- #{files.join(' ')}"
+                     end
+          if !push?
+            source('git branch -vv --list', io: true, banner: false)[0].each do |val|
+              origin = %r{^\* [^\[]+(?<= )\[([\w.-/]+?)/([\w.-]+)\] }.match(val)
+              next unless origin
+
+              @origin = origin[1]
+              @branch = origin[2]
+              break
+            end
+          end
+          raise ArgumentError, message('commit', 'work tree is not usable') unless push?
+
+          cmd = git_session 'commit'
+          cmd << '--dry-run' if option('dry-run')
+          if amend
+            cmd << '--amend'
+          else
+            cmd.delete('--amend')
+          end
+          if message
+            append_message message
+          elsif flag == :'amend-orig' || option('no-edit')
+            cmd << '--no-edit'
+          end
+          a = ['git add --verbose']
+          b = ['git push']
+          if dry_run?
+            a << '--dry-run'
+            b << '--dry-run'
+          end
+          a << pathspec
+          b << '--force' if amend
+          b << @origin << @branch
+          puts if pass
+          source a.join(' ')
+          source
+          source b.join(' ')
+        end
+
+        protected
+
+        def source(cmd = @session, exception: true, banner: true, io: false, sync: true, stdout: false, stderr: false)
+          cmd = close_session(cmd)
+          info cmd
+          begin
+            banner = format_banner(cmd.gsub(trailing_slash(@path), ''), banner: banner, multitask: true)
+            cmd = cmd.sub(/^git\b/, "git --work-tree #{shell_quote(@path)} --git-dir #{shell_quote(vardir)}")
+            if io
+              [IO.popen(cmd), banner]
+            elsif pipe? ? sync : stdout
+              print_item banner
+              puts `#{cmd}`
+            elsif sync || (!exception && !stderr)
+              print_item banner
+              shell(cmd, exception: exception)
+            else
+              require 'open3'
+              if stderr
+                Open3.popen3(cmd) do |_, out, err|
+                  ret = write_lines(out, banner: banner, pass: true)
+                  if ret == 0
+                    write_lines(err, banner: banner)
+                  else
+                    write_lines(err, loglevel: Logger::DEBUG)
+                  end
+                end
+              else
+                Open3.popen2e(cmd) { |_, out| write_lines(out, banner: banner) }
+              end
+            end
+          rescue StandardError => e
+            error e
+            raise if exception
+
+            emphasize e, message('git', cmd)
+          end
+        end
+
+        def write_lines(iter, banner: nil, loglevel: nil, grep: nil, sub: nil, pass: false)
+          grep = Regexp.new(grep == '*' ? '.+' : grep) if grep.is_a?(::String)
+          sub = nil if pipe?
+          found = 0
+          lines = []
+          iter.each do |line|
+            next if grep && !grep.match?(line)
+
+            if loglevel
+              log loglevel, line
+            else
+              sub&.each { |h| line = sub_style(line, **h) }
+              if banner
+                lines << line
+              else
+                puts line
+              end
+            end
+            found += 1
+          end
+          print_item banner, lines if banner && (found > 0 || !pass)
+          found
+        end
+
+        def list_result(size, type, action: 'found', grep: nil)
+          return unless verbose?
+
+          if size > 0
+            args = styles[:banner]&.reject { |s| s.to_s.end_with?('!') } || []
+            args << :bold if args.size <= 1
+            puts Project.footer "#{sub_style(size, *args)} #{size == 1 ? type.sub(/s$/, '') : type}"
+          else
+            puts empty_status("No #{type} were #{action}", 'grep', grep)
+          end
+        end
+
+        def source_path(files)
+          files.select { |val| source_path?(val) }.map { |val| shell_quote(base_path(val.strip)) }
+        end
+
+        def source_path?(path)
+          return path.to_s.start_with?("#{@path}#{::File::SEPARATOR}") if Pathname.new(path).absolute?
+
+          !%r{^\.\.[/\\]}.match?(path)
+        end
+
+        private
+
+        def append_pathspec(files)
+          files = source_path(files)
+          @session << "-- #{files.join(' ')}" unless files.empty?
+        end
+
+        def append_message(val)
+          @session << "--message \"#{double_quote(val)}\"" if val
+        end
+
+        def invoked_sync?(action, flag = nil)
+          !flag.nil? || super(action)
+        end
+
+        def option(val)
+          ret = ENV.fetch("GIT_#{val.gsub(/\W/, '_').upcase}", '')
+          ret unless ret.empty? || ret == '0'
+        end
+
+        def git_session(*cmd)
+          session('git', *cmd)
+        end
+
+        def vardir
+          @vardir ||= base_path('.git')
+        end
+
+        def push?
+          !@origin.nil? && !@branch.nil?
+        end
+
+        def dry_run?
+          @session.include?('--dry-run')
+        end
+      end
+    end
+  end
+end