eac_tools 0.99.1 → 0.101.0

data/sub/eac_git/lib/eac_git/executables.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EacGit
+  module Executables
+    class << self
+      include ::EacRubyUtils::SimpleCache
+
+      def env
+        ::EacRubyUtils::Envs.local
+      end
+
+      private
+
+      def git_uncached
+        r = env.executable('git', '--version')
+        r.extend(GitCommandExtensions)
+        r
+      end
+
+      def tar_uncached
+        env.executable('tar', '--version')
+      end
+
+      module GitCommandExtensions
+        def command(*args)
+          super.envvar('PATH', path_with_git_subrepo)
+        end
+
+        def gem_root
+          '../..'.to_pathname.expand_path(__dir__)
+        end
+
+        def git_subrepo_root
+          gem_root.join('vendor', 'git-subrepo')
+        end
+
+        def path_with_git_subrepo
+          ([git_subrepo_root.join('lib').to_path] +
+              ENV['PATH'].if_present('').split(::File::PATH_SEPARATOR))
+            .join(::File::PATH_SEPARATOR)
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/branch.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Branch
+      REFS_PREFIX = 'refs/heads/'
+
+      common_constructor :local, :name
+
+      # @return [String]
+      # @deprecated Use {#head_commit_id} instead.
+      def current_commit_id
+        head_commit_id
+      end
+
+      # @return [Boolean]
+      def exist?
+        local.command('show-ref', '--quiet', full_ref_name).execute.fetch(:exit_code).zero?
+      end
+
+      def full_ref_name
+        "#{REFS_PREFIX}#{name}"
+      end
+
+      # @return [EacGit::Local::Commit]
+      def head_commit
+        local.commit(head_commit_id, true)
+      end
+
+      # @return [String]
+      def head_commit_id
+        local.rev_parse(full_ref_name, true)
+      end
+
+      # @param remote [EacGit::Local::Remote]
+      # @return [void]
+      def push(remote, options = {})
+        options[:refspec] = name
+        options.inject(remote.push) do |a, e|
+          a.send(*e)
+        end.perform
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/changed_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class ChangedFile
+      QUOTED_PATH_PATTERN = /\A"(.+)"\z/.freeze
+      STATUS_LINE_PATTERN = /\A(.)(.)\s(.+)\z/.freeze
+
+      class << self
+        def by_porcelain_v1_line(local_repo, line)
+          STATUS_LINE_PATTERN.match(line.gsub(/\n\z/, '')).then do |m|
+            new(local_repo, m[1], m[2], parse_status_line_path(m[3]).to_pathname)
+          end
+        end
+
+        # @param path [String]
+        # @return [String]
+        def parse_status_line_path(path)
+          m = QUOTED_PATH_PATTERN.match(path)
+          m ? m[1] : path
+        end
+      end
+
+      common_constructor :local_repo, :index, :worktree, :path
+
+      # @return [Pathname]
+      def absolute_path
+        path.expand_path(local_repo.root_path)
+      end
+
+      # @return [Boolean]
+      def add?
+        (index == '?' && worktree == '?') || (index == 'A' && worktree == ' ')
+      end
+
+      # @return [Boolean]
+      def delete?
+        [index, worktree].include?('D')
+      end
+
+      # @return [Boolean]
+      def modify?
+        [index, worktree].include?('M')
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/commit/archive.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Commit
+      module Archive
+        # @return [EacRubyUtils::Envs::Command]
+        def archive_to_dir(path)
+          path = path.to_pathname
+          repo.command('archive', '--format=tar', id).pipe(
+            ::EacGit::Executables.tar.command('-xC', path)
+          )
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/commit/changed_file.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Commit
+      class ChangedFile
+        enable_simple_cache
+
+        attr_reader :commit, :diff_tree
+
+        # @param commit [EacGit::Local::Commit]
+        # @param diff_tree_line [String] A line from command "repo diff-tree --no-commit-id -r
+        #   --full-index"'s output.
+        def initialize(commit, diff_tree_line)
+          @commit = commit
+          @diff_tree = ::EacGit::Local::Commit::DiffTreeLine.new(diff_tree_line)
+        end
+
+        delegate(*::EacGit::Local::Commit::DiffTreeLine::FIELDS, to: :diff_tree)
+
+        def to_s
+          "#{path}|#{status}"
+        end
+
+        def src_size_uncached
+          size(src_sha1)
+        end
+
+        def dst_size_uncached
+          size(dst_sha1)
+        end
+
+        private
+
+        def size(id)
+          return 0 if /\A0+\z/.match(id)
+
+          commit.repo.command('cat-file', '-s', id).execute!.strip.to_i
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/commit/diff_tree_line.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Commit
+      class DiffTreeLine
+        DIFF_TREE_PATTERN = /\A:(\d{6}) (\d{6}) (\S+) (\S+) (\S+)\t(\S.*)\z/.freeze
+        FIELDS = %w[src_mode dst_mode src_sha1 dst_sha1 status path].freeze
+        GIT_COMMAND_ARGS = %w[-c core.quotepath=off diff-tree --no-commit-id -r --full-index].freeze
+
+        attr_reader(*FIELDS)
+
+        # line: a line of command "git [GIT_COMMAND_ARGS]"'s output.
+        # Reference: https://git-scm.com/docs/git-diff-tree
+        def initialize(line)
+          m = DIFF_TREE_PATTERN.match(line.strip)
+          raise "\"#{line}\" did not match pattern" unless m
+
+          FIELDS.count.times { |i| send("#{FIELDS[i]}=", m[i + 1]) }
+        end
+
+        def fields
+          FIELDS.index_with { |field| send(field) }
+        end
+
+        private
+
+        attr_writer(*FIELDS)
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/commit.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Commit
+      require_sub __FILE__, include_modules: true
+      enable_simple_cache
+      include ::Comparable
+
+      FIELDS = {
+        author_name: '%an', author_email: '%ae', author_date: '%ai',
+        subject: '%s',
+        author_all: '%an <%ae>, %ai',
+        commit_hash: '%H', abbreviated_commit_hash: '%h',
+        commiter_name: '%cn', commiter_email: '%ce', commiter_date: '%ci',
+        commiter_all: '%cn <%ce>, %ci',
+        raw_body: '%B'
+      }.freeze
+
+      common_constructor :repo, :id
+
+      def <=>(other)
+        [repo, id] <=> [other.repo, other.id]
+      end
+
+      def format(format)
+        repo.command('--no-pager', 'log', '-1', "--pretty=format:#{format}", id).execute!.strip
+      end
+
+      FIELDS.each do |field, format|
+        define_method(field) { format(format) }
+      end
+
+      def changed_files_uncached
+        diff_tree_execute.each_line.map do |line|
+          ::EacGit::Local::Commit::ChangedFile.new(self, line)
+        end
+      end
+
+      def changed_files_size_uncached
+        changed_files.inject(0) { |a, e| a + e.dst_size }
+      end
+
+      # @return [EacGit::Local::Commit, nil]
+      def parent
+        ps = parents
+        raise "#{self} has more than one parent" if ps.count > 2
+
+        ps.empty? ? nil : ps.first
+      end
+
+      # @return [Array<EacGit::Local::Commit>]
+      def parents
+        format('%P').each_line.map { |line| repo.commitize(line) } # rubocop:disable Style/RedundantFormat
+      end
+
+      def root_child?
+        parents.empty?
+      end
+
+      private
+
+      def diff_tree_execute
+        args = []
+        args << '--root' if root_child?
+        args << id
+        repo.command(*::EacGit::Local::Commit::DiffTreeLine::GIT_COMMAND_ARGS, *args).execute!
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/dirty_files.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module EacGit
+  class Local
+    module DirtyFiles
+      def dirty?
+        dirty_files.any?
+      end
+
+      def dirty_file?(path)
+        absolute_path = path.to_pathname.expand_path(root_path)
+        dirty_files.any? do |df|
+          df.absolute_path == absolute_path
+        end
+      end
+
+      def dirty_files
+        command('status', '--porcelain=v1', '--untracked-files', '--no-renames')
+          .execute!.each_line
+          .map { |line| ::EacGit::Local::ChangedFile.by_porcelain_v1_line(self, line) }
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/log.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    module Log
+      def log(until_commit = nil, from_commit = nil)
+        until_commit, from_commit = [until_commit, from_commit].map { |c| commitize(c) }
+        from_commit ||= head
+        command('log', '--format=%H', "#{until_commit.id}..#{from_commit.id}")
+          .execute!.each_line.map { |line| commitize(line.strip) }
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/remote/push.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Remote
+      class Push
+        acts_as_immutable
+        immutable_accessor :force, type: :boolean
+        immutable_accessor :refspec, type: :array
+
+        common_constructor :remote
+        delegate :local, to: :remote
+
+        # @return [Array<Object>]
+        def immutable_constructor_args
+          [remote]
+        end
+
+        # @return [void]
+        def perform
+          local.command(*git_command_args).system!
+        end
+
+        # @return [Enumerable<String>]
+        def git_command_args
+          r = ['push', remote.name]
+          r << '--force' if force?
+          r + refspecs
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/remote.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Remote
+      NO_SUCH_REMOTE_CODE = 512
+
+      enable_simple_cache
+      include ::EacGit::RemoteLike
+
+      common_constructor :local, :name
+
+      def exist?
+        url
+      end
+
+      # @return [EacRubyUtils::Envs::Command
+      def git_command(*args)
+        local.command(*args)
+      end
+
+      # @return [EacGit::Local::Remote::Push]
+      def push
+        ::EacGit::Local::Remote::Push.new(self)
+      end
+
+      # @return [String]
+      def remote_reference
+        name
+      end
+
+      # @return [String, nil]
+      def url
+        local.command('remote', 'get-url', name)
+          .execute!(exit_outputs: { NO_SUCH_REMOTE_CODE => nil })
+          .if_present(nil, &:strip)
+      end
+
+      # @return [String]
+      def url=(new_url)
+        local.command('remote', 'set-url', name, new_url).execute!
+      end
+
+      require_sub __FILE__
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/remotes.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    module Remotes
+      def remote(name)
+        ::EacGit::Local::Remote.new(self, name)
+      end
+
+      def remotes
+        command('remote').execute!.each_line.map(&:strip).compact_blank.map do |name|
+          remote(name)
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/subrepo/config.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    class Subrepo
+      class Config
+        MAPPING = {
+          command_version: :cmdver, commit_id: :commit, join_method: :method,
+          parent_commit_id: :parent, remote_branch: :branch, remote_uri: :remote
+        }.freeze
+
+        class << self
+          def from_file(file_path)
+            new(
+              ::ParseConfig.new(file_path.to_pathname)['subrepo']
+            )
+          end
+        end
+
+        common_constructor :values do
+          self.values = values.with_indifferent_access
+        end
+
+        MAPPING.each_key do |method_name|
+          define_method(method_name) do
+            values[MAPPING.fetch(method_name)]
+          end
+
+          define_method("#{method_name}=") do |value|
+            values[MAPPING.fetch(method_name)] = value
+          end
+        end
+
+        def to_content
+          "[subrepo]\n" + MAPPING.map { |k, v| "  #{v} = #{send(k)}\n" }.join # rubocop:disable Style/StringConcatenation
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local/subrepo.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module EacGit
+  class Local
+    # A git-subrepo (https://github.com/ingydotnet/git-subrepo) in a [EacGit::Local].
+    class Subrepo
+      require_sub __FILE__
+      enable_simple_cache
+
+      common_constructor :local, :subpath do
+        self.subpath = subpath.to_pathname
+        local.raise_error "Config file \"#{config_absolute_path}\" not found" unless
+          config_absolute_path.file?
+      end
+
+      def command(subrepo_subcommand, *subrepo_subcommand_args)
+        local.command('subrepo', subrepo_subcommand, subpath.to_path,
+                      *subrepo_subcommand_args)
+      end
+
+      delegate(*::EacGit::Local::Subrepo::Config::MAPPING.keys, to: :config)
+
+      def write_config
+        config_absolute_path.write(config.to_content)
+      end
+
+      private
+
+      def config_uncached
+        ::EacGit::Local::Subrepo::Config.from_file(config_absolute_path)
+      end
+
+      def config_absolute_path_uncached
+        config_relative_path.expand_path(local.root_path)
+      end
+
+      def config_relative_path_uncached
+        subpath.join('.gitrepo')
+      end
+
+      def remote_uncached
+        ::EacGit::Remote.new(remote_uri)
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/local.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module EacGit
+  # A Git repository in local filesystem.
+  class Local
+    require_sub __FILE__, include_modules: true
+    include ::Comparable
+
+    HEAD_REFERENCE = 'HEAD'
+
+    class << self
+      def find(path)
+        path = path.to_pathname.expand_path
+        if path.join('.git').exist?
+          new(path)
+        elsif path.to_path != '/'
+          find(path.parent)
+        end
+      end
+    end
+
+    common_constructor :root_path do
+      self.root_path = root_path.to_pathname
+    end
+
+    def <=>(other)
+      root_path <=> other.root_path
+    end
+
+    # Retrieves a local branch.
+    #
+    # @param name [String] Ex.: for "refs/heads/master", name should be "master".
+    # @return [EacGit::Local::Branch]
+    def branch(name)
+      ::EacGit::Local::Branch.new(self, name)
+    end
+
+    def commit(ref, required = false) # rubocop:disable Style/OptionalBooleanParameter
+      rev_parse(ref, required).if_present { |v| ::EacGit::Local::Commit.new(self, v) }
+    end
+
+    def commitize(source)
+      if source.is_a?(::EacGit::Local::Commit)
+        return source if source.repo == self
+
+        source = source.id
+      end
+
+      source.to_s.strip.if_present(nil) { |v| ::EacGit::Local::Commit.new(self, v) }
+    end
+
+    # Retrieves the current local branch.
+    #
+    # @return [EacGit::Local::Branch, nil]
+    def current_branch
+      command('symbolic-ref', '--quiet', HEAD_REFERENCE)
+        .execute!(exit_outputs: { 256 => '' })
+        .gsub(%r{\Arefs/heads/}, '').strip
+        .if_present { |v| branch(v) }
+    end
+
+    def descendant?(descendant, ancestor)
+      base = merge_base(descendant, ancestor)
+      return false if base.blank?
+
+      revparse = command('rev-parse', '--verify', ancestor).execute!.strip
+      base == revparse
+    end
+
+    # @return [EacGit::Local::Commit
+    def head(required = true) # rubocop:disable Style/OptionalBooleanParameter
+      commit(HEAD_REFERENCE, required)
+    end
+
+    def merge_base(*commits)
+      refs = commits.dup
+      while refs.count > 1
+        refs[1] = merge_base_pair(refs[0], refs[1])
+        return nil if refs[1].blank?
+
+        refs.shift
+      end
+      refs.first
+    end
+
+    def command(*args)
+      ::EacGit::Executables.git.command('-C', root_path.to_path, *args)
+    end
+
+    def raise_error(message)
+      raise "#{root_path}: #{message}"
+    end
+
+    def rev_parse(ref, required = false) # rubocop:disable Style/OptionalBooleanParameter
+      r = command('rev-parse', ref).execute!(exit_outputs: { 128 => nil, 32_768 => nil })
+      r.strip! if r.is_a?(String)
+      return r if r.present?
+      return nil unless required
+
+      raise_error "Reference \"#{ref}\" not found"
+    end
+
+    def subrepo(subpath)
+      ::EacGit::Local::Subrepo.new(self, subpath)
+    end
+
+    # @return [Array<EacGit::Local::Subrepo>]
+    def subrepos
+      command('subrepo', '-q', 'status').execute!.split("\n").map(&:strip).select(&:present?)
+        .map { |subpath| subrepo(subpath) }
+    end
+
+    def to_s
+      "#{self.class}[#{root_path}]"
+    end
+
+    private
+
+    def merge_base_pair(commit1, commit2)
+      command('merge-base', commit1, commit2).execute!(exit_outputs: { 256 => nil })
+        .if_present(nil, &:strip)
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/remote.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacGit
+  # A Git remote repository referenced by URI.
+  class Remote
+    include ::EacGit::RemoteLike
+
+    common_constructor :uri
+
+    # @return [EacRubyUtils::Envs::Command
+    def git_command(...)
+      ::EacGit::Executables.git.command(...)
+    end
+
+    # @return [String]
+    def remote_reference
+      uri
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/remote_like/ls_result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EacGit
+  module RemoteLike
+    class LsResult
+      class << self
+        def by_ls_remote_command_output(output)
+          new(
+            output.each_line.map { |line| line.strip.split(/\s+/) }.to_h { |x| [x[1], x[0]] } # rubocop:disable Style/MapToHash
+          )
+        end
+      end
+
+      common_constructor :hashes
+      delegate :fetch, :[], :count, :any?, :empty?, to: :hashes
+    end
+  end
+end