eac_tools 0.123.0 → 0.123.1

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,71 @@
+# 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
+
+      # @return [String]
+      def add(url)
+        local.command('remote', 'add', name, url).execute!
+      end
+
+      # @return [Boolean]
+      def exist?
+        url.present?
+      end
+
+      # @return [EacRubyUtils::Envs::Command
+      def git_command(*)
+        local.command(*)
+      end
+
+      # @return [EacGit::Local::Remote::Push]
+      def push
+        ::EacGit::Local::Remote::Push.new(self)
+      end
+
+      # @return [String]
+      def remote_reference
+        name
+      end
+
+      # @return [String]
+      def remove
+        local.command('remote', 'remove', name).execute!
+      end
+
+      # @return [String, nil]
+      def url
+        url_get(exit_outputs: { NO_SUCH_REMOTE_CODE => nil }).if_present(nil, &:strip)
+      end
+
+      # @return [String]
+      def url=(new_url)
+        case [exist?, new_url.present?]
+        when [false, false] # do nothing
+        when [false, true] then add(new_url)
+        when [true, false] then remove
+        when [true, true] then url_set(new_url)
+        else ibr
+        end
+      end
+
+      # @return [String, nil]
+      def url_get(**)
+        local.command('remote', 'get-url', name).execute!(**)
+      end
+
+      # @param url [String]
+      # @return [String]
+      def url_set(url)
+        local.command('remote', 'set-url', name, url).execute!
+      end
+    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.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::Subrepo::Configuration::MAPPING.keys, to: :config)
+
+      def write_config
+        config_absolute_path.write(config.to_content)
+      end
+
+      private
+
+      def config_uncached
+        ::EacGit::Subrepo::Configuration.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 # rubocop:disable Style/CollectionQuerying
+        refs[1] = merge_base_pair(refs[0], refs[1])
+        return nil if refs[1].blank?
+
+        refs.shift
+      end
+      refs.first
+    end
+
+    def command(*)
+      ::EacGit::Executables.git.command('-C', root_path.to_path, *)
+    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,19 @@
+# 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]] }
+          )
+        end
+      end
+
+      common_constructor :hashes
+      compare_by :hashes
+      delegate :fetch, :[], :count, :any?, :empty?, to: :hashes
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacGit
+  module RemoteLike
+    enable_abstract_methods
+
+    # @return [String] The output of command "git fetch".
+    def fetch
+      local.command('fetch', name).execute!
+    end
+
+    # @return [EacRubyUtils::Envs::Command
+    def git_command(*_args)
+      raise_abstract_method __method__
+    end
+
+    # @return [EacGit::RemoteLike::LsResult]
+    def ls
+      ::EacGit::RemoteLike::LsResult.by_ls_remote_command_output(
+        git_command('ls-remote', remote_reference).execute!
+      )
+    end
+
+    # @return [String]
+    def remote_reference
+      raise_abstract_method __method__
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/setup.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacGit
+  module Rspec
+    module Setup
+      def self.extended(setup_obj)
+        setup_obj.setup_conditional_git
+        setup_obj.setup_stubbed_git_local_repo
+      end
+
+      def setup_conditional_git
+        conditional(:git) { ::EacGit::Executables.git.validate }
+      end
+
+      def setup_stubbed_git_local_repo
+        rspec_config.include ::EacGit::Rspec::StubbedGitLocalRepo
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/stubbed_git_local_repo/directory.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module EacGit
+  module Rspec
+    module StubbedGitLocalRepo
+      class Directory < ::EacGit::Rspec::StubbedGitLocalRepo::FsObject
+        # @return [self]
+        def create
+          ::FileUtils.mkdir_p(path)
+          self
+        end
+
+        # @return [self]
+        def delete
+          ::FileUtils.rm_rf(path)
+          self
+        end
+
+        # @param subpath [Array<String>]
+        # @return [EacGit::Rspec::StubbedGitLocalRepo::Directory]
+        def directory(*subpath)
+          git.directory(*self.subpath, *subpath)
+        end
+
+        # @param subpath [Array<String>]
+        # @return [EacGit::Rspec::StubbedGitLocalRepo::File]
+        def file(*subpath)
+          git.file(*self.subpath, *subpath)
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/stubbed_git_local_repo/file.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module EacGit
+  module Rspec
+    module StubbedGitLocalRepo
+      class File < ::EacGit::Rspec::StubbedGitLocalRepo::FsObject
+        def touch
+          ::FileUtils.touch(path.to_path)
+        end
+
+        def delete
+          path.unlink
+        end
+
+        delegate :write, to: :path
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/stubbed_git_local_repo/fs_object.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module EacGit
+  module Rspec
+    module StubbedGitLocalRepo
+      class FsObject
+        # @!attribute [r] git
+        #   @param git [EacGit::Rspec::StubbedGitLocalRepo::Repository]
+
+        # @!attribute [r] subpath
+        #   @param git [Array<String>]
+
+        # @!method initialize(git, subpath)
+        #   @param git [EacGit::Rspec::StubbedGitLocalRepo::Repository]
+        #   @param subpath [Array<String>
+        common_constructor :git, :subpath
+
+        # @return [Pathname]
+        def path
+          git.root_path.join(*subpath)
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/stubbed_git_local_repo/repository.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module EacGit
+  module Rspec
+    module StubbedGitLocalRepo
+      class Repository < ::EacGit::Local
+        # @return [EacGit::Rspec::StubbedGitLocalRepo::Directory]
+        def directory(*subpath)
+          ::EacGit::Rspec::StubbedGitLocalRepo::Directory.new(self, subpath)
+        end
+
+        def file(*subpath)
+          ::EacGit::Rspec::StubbedGitLocalRepo::File.new(self, subpath)
+        end
+
+        # @return [EacGit::Local::Commit
+        def random_commit
+          content = ::SecureRandom.hex
+          file = "#{content}.txt"
+          file(file).write(content)
+          command('add', file).execute!
+          command('commit', '-m', "Random commit: #{file}.").execute!
+          head
+        end
+      end
+    end
+  end
+end

data/sub/eac_git/lib/eac_git/rspec/stubbed_git_local_repo.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+
+module EacGit
+  module Rspec
+    module StubbedGitLocalRepo
+      def stubbed_git_local_repo(bare = false) # rubocop:disable Style/OptionalBooleanParameter
+        path = ::Dir.mktmpdir
+        ::EacRubyUtils::Envs.local.command(stubbed_git_local_repo_args(path, bare)).execute!
+        repo = ::EacGit::Rspec::StubbedGitLocalRepo::Repository.new(path)
+        repo.command('config', 'user.email', 'theuser@example.net').execute!
+        repo.command('config', 'user.name', 'The User').execute!
+        repo
+      end
+
+      private
+
+      def stubbed_git_local_repo_args(path, bare)
+        r = %w[git init]
+        r << '--bare' if bare
+        r + [path]
+      end
+    end
+  end
+end

data/sub/{eac_config/lib/eac_config → eac_git/lib/eac_git}/rspec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module EacConfig
+module EacGit
   module Rspec
   end
 end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'parseconfig'
+
+module EacGit
+  module Subrepo
+    class Configuration
+      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

data/sub/{eac_cli/lib/eac_cli → eac_git/lib/eac_git}/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module EacCli
-  VERSION = '0.47.2'
+module EacGit
+  VERSION = '0.21.0'
 end

data/sub/{avm-eac_generic_base0/lib/avm/eac_generic_base0.rb → eac_git/lib/eac_git.rb}

@@ -3,9 +3,5 @@
 require 'eac_ruby_utils'
 EacRubyUtils::RootModuleSetup.perform __FILE__
 
-module Avm
-  module EacGenericBase0
-  end
+module EacGit
 end
-
-require 'avm'

data/sub/eac_git/spec/lib/eac_git/executables_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacGit::Executables, :git) do
+  it 'output version' do
+    expect(described_class.git.command('--version').execute!).to be_present
+  end
+
+  it 'subrepo output version' do
+    expect(described_class.git.command('subrepo', '--version').execute!).to be_present
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe EacGit::Local::Commit::DiffTreeLine, :git do
+  include_examples 'source_target_fixtures', __FILE__ do
+    def source_data(source_file)
+      File.read(source_file).each_line.map do |line|
+        described_class.new(line).fields
+      end
+    end
+  end
+end

data/sub/eac_git/spec/lib/eac_git/local/commit/diff_tree_line_spec_files/add.source.out

@@ -0,0 +1 @@
+:000000 100644 0000000000000000000000000000000000000000 f380aec0bd8dd777edac43b11636e46cad04273a A	nomes.txt

data/sub/eac_git/spec/lib/eac_git/local/commit/diff_tree_line_spec_files/add.target.yaml

@@ -0,0 +1,7 @@
+---
+- src_mode: '000000'
+  dst_mode: '100644'
+  src_sha1: '0000000000000000000000000000000000000000'
+  dst_sha1: f380aec0bd8dd777edac43b11636e46cad04273a
+  status: A
+  path: nomes.txt

data/sub/eac_git/spec/lib/eac_git/local/commit/diff_tree_line_spec_files/modify.source.out

@@ -0,0 +1 @@
+:100644 100644 40bcdecb4214cd8a3fcf96cd25a2beb87e7e7cd8 4a30dfae816b984f05cfb594e0d5958bb8c387ae M	nomes.txt