eac_tools 0.86.0 → 0.86.2

data/sub/avm-git/lib/avm/git/organize/reference_update.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Organize
+      class ReferenceUpdate
+        enable_listable
+        lists.add_symbol :operation, :remove
+
+        common_constructor :repository, :reference, :operation
+
+        def run_operation
+          send("run_operation_#{operation}")
+        end
+
+        def to_s
+          "#{reference} [#{operation}]"
+        end
+
+        private
+
+        def reference_pathname
+          repository.refs_root.join(reference)
+        end
+
+        def run_operation_remove
+          reference_pathname.unlink
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/organize/repository.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'avm/git/organize/reference_update'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Organize
+      class Repository
+        enable_simple_cache
+        common_constructor :eac_git_local
+
+        def collected_references
+          @collected_references || []
+        end
+
+        def collect_subrepos
+          collect_references_with_pattern(
+            %r{\Asubrepo/},
+            ::Avm::Git::Organize::ReferenceUpdate::OPERATION_REMOVE
+          )
+          collect_references_with_pattern(
+            %r{\Aheads/subrepo/},
+            ::Avm::Git::Organize::ReferenceUpdate::OPERATION_REMOVE
+          )
+        end
+
+        def collect_originals
+          collect_references_with_pattern(
+            %r{\Aoriginal/},
+            ::Avm::Git::Organize::ReferenceUpdate::OPERATION_REMOVE
+          )
+        end
+
+        def all_branches
+          eac_git_local.execute!
+        end
+
+        delegate :to_s, to: :eac_git_local
+
+        private
+
+        def all_references
+          ::Pathname.glob("#{refs_root}/**/*").select(&:file?)
+            .map { |p| p.relative_path_from(refs_root).to_path }
+        end
+
+        def reference_update_by_ref(reference)
+          collected_references.find { |ru| ru.reference == reference }
+        end
+
+        def collect_reference(reference, operation)
+          new_ru = ::Avm::Git::Organize::ReferenceUpdate.new(self, reference, operation)
+          reference_update_by_ref(new_ru.reference).if_present do |ru_found|
+            raise "Reference #{new_ru} already added (#{ru_found})"
+          end
+          @collected_references ||= []
+          @collected_references << new_ru
+        end
+
+        def collect_references_with_pattern(pattern, operation)
+          references_with_pattern(pattern).each do |reference|
+            collect_reference(reference, operation)
+          end
+        end
+
+        def references_with_pattern(pattern)
+          all_references.select { |reference| pattern.if_match(reference, false) }
+        end
+
+        def refs_root_uncached
+          eac_git_local.root_path / '.git' / 'refs'
+        end
+      end
+    end
+  end
+end

data/sub/{avm-eac_php_base0/lib/avm/eac_php_base0/source_generators.rb → avm-git/lib/avm/git/organize.rb}

@@ -3,8 +3,8 @@
 require 'eac_ruby_utils/core_ext'
 
 module Avm
-  module EacPhpBase0
-    module SourceGenerators
+  module Git
+    module Organize
       require_sub __FILE__
     end
   end

data/sub/avm-git/lib/avm/git/revision_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/ruby'
+
+module Avm
+  module Git
+    class RevisionTest
+      enable_simple_cache
+      enable_speaker
+      common_constructor :git, :sha1, :options
+
+      def banner
+        infov 'Revision to test', sha1
+        ::EacRubyUtils::Speaker.context.on(::EacCli::Speaker.new(err_line_prefix: '  ')) do
+          revision_banner
+        end
+      end
+
+      def successful_label
+        successful?.to_s.send((successful? ? :green : :red))
+      end
+
+      def to_s
+        sha1
+      end
+
+      def successful?
+        successful
+      end
+
+      private
+
+      def checkout_revision
+        infom 'Checking out revision...'
+        git.execute!('checkout', sha1)
+      end
+
+      def commit_uncached
+        ::Avm::Git::Commit.new(git, sha1)
+      end
+
+      def git_absolute_path
+        ::File.expand_path(git.to_s)
+      end
+
+      def revision_banner
+        infov '* Subject', commit.subject
+        infov '* Success?', successful_label
+        infov '* STDOUT', stdout_cache.content_path
+        infov '* STDERR', stderr_cache.content_path
+      end
+
+      def root_cache
+        fs_cache.child(git_absolute_path.parameterize, sha1,
+                       options.fetch(:test_command).to_s.parameterize)
+      end
+
+      def run_test
+        infom "Running test command \"#{::Shellwords.join(test_command_args)}\" " \
+              "on \"#{git_absolute_path}\"..."
+        result = ::EacRubyUtils::Ruby.on_clean_environment { test_command.execute }
+        infom 'Test done'
+        write_result_cache(result)
+      end
+
+      def stdout_cache
+        root_cache.child('stdout')
+      end
+
+      def stderr_cache
+        root_cache.child('stderr')
+      end
+
+      def successful_cache
+        root_cache.child('successful')
+      end
+
+      def successful_uncached
+        if options.fetch(:no_cache) || !successful_cache.stored?
+          checkout_revision
+          run_test
+        end
+        successful_cache.read == 'true'
+      end
+
+      def test_command
+        ::EacRubyUtils::Envs.local.command(*test_command_args).chdir(git.to_s)
+      end
+
+      def test_command_args
+        r = ::Shellwords.split(options.fetch(:test_command).to_s)
+        return r if r.any?
+
+        raise 'No command found'
+      end
+
+      def write_result_cache(result)
+        stdout_cache.write(result[:stdout])
+        stderr_cache.write(result[:stderr])
+        successful_cache.write(result[:exit_code].zero? ? 'true' : 'false')
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/branch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/scms/branch'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Branch < ::Avm::Scms::Branch
+          common_constructor :scm, :eac_git_branch
+
+          # @return [Avm::Git::Scms::Git::Commit]
+          def head_commit
+            ::Avm::Git::Scms::Git::Commit.new(scm, eac_git_branch.head_commit)
+          end
+
+          # @return [String]
+          def id
+            eac_git_branch.name
+          end
+
+          # @param remote [Avm::Git::Scms::Git::Remote]
+          def push(remote)
+            eac_git_branch.push(remote.eac_git_remote, force: true)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/branches.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        module Branches
+          # @return [Avm::Git::Scms::Git::Branch]
+          def head_branch
+            ::Avm::Git::Scms::Git::Branch.new(self,
+                                              git_repo.current_branch)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/change_tracker.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class ChangeTracker
+          common_constructor :git_scm, :commit_info
+          attr_reader :starting_commit
+
+          delegate :git_repo, to: :git_scm
+
+          def start
+            raise 'Repository is dirty' if git_repo.dirty?
+
+            self.starting_commit = git_repo.head
+          end
+
+          # @return [Avm::Git::Scms::Git::Commit, nil]
+          def stop
+            git_scm.commit_dirty
+            return nil if starting_commit == git_repo.head
+
+            git_scm.reset_and_commit(starting_commit, commit_info)
+          end
+
+          private
+
+          attr_writer :starting_commit
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/changed_file.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'avm/scms/changed_file'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class ChangedFile < ::Avm::Scms::ChangedFile
+          common_constructor :scm, :path
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/changed_files.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'avm/git/scms/git/changed_file'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class ChangedFiles
+          enable_method_class
+          common_constructor :scm
+
+          # @return [Avm::Git::Scms::Git::ChangedFile]
+          def result
+            scm.git_repo.dirty_files.map do |dirty_file|
+              ::Avm::Git::Scms::Git::ChangedFile.new(scm, dirty_file.path)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/commit/deploy.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'avm/files/appendable'
+require 'avm/files/deploy'
+require 'avm/scms/base'
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Commit < ::Avm::Scms::Commit
+          class Deploy
+            include ::Avm::Files::Appendable
+            enable_simple_cache
+
+            attr_reader :build_dir, :commit, :target_env, :target_path
+
+            def initialize(commit, target_env, target_path)
+              @commit = commit
+              @target_env = target_env
+              @target_path = target_path
+            end
+
+            def run
+              fd = ::Avm::Files::Deploy.new(target_env, target_path)
+              fd.append_tar_output_command(git_archive_command)
+              fd.appended.push(*appended)
+              fd.run
+            end
+
+            private
+
+            def git_archive_command
+              commit.git_repo.command('archive', '--format=tar', commit.id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/commit/deploy_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'avm/git/commit'
+require 'avm/git/scms/git/commit/deploy'
+require 'avm/scms/base'
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Commit < ::Avm::Scms::Commit
+          module DeployMethods
+            def deploy_to_env_path(target_env, target_path)
+              ::Avm::Git::Scms::Git::Commit::Deploy.new(self, target_env, target_path)
+            end
+
+            def deploy_to_url(target_url)
+              ::Avm::Git::Scms::Git::Commit::Deploy.new(
+                self,
+                *::Avm::Git::Commit.target_url_to_env_path(target_url)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/commit.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Commit < ::Avm::Scms::Commit
+          require_sub __FILE__, include_modules: true
+          common_constructor :git_scm, :git_commit do
+            git_commit.assert_argument(::EacGit::Local::Commit, 'git_commit')
+          end
+          delegate :git_repo, to: :git_scm
+          delegate :id, to: :git_commit
+
+          FIXUP_SUBJECT_PATTERN = /\Afixup!/.freeze
+
+          # @return [Array<Pathname>]
+          def changed_files
+            git_commit.changed_files.map { |cf| cf.path.to_pathname }
+          end
+
+          # @return [Boolean]
+          def fixup?
+            FIXUP_SUBJECT_PATTERN.match?(git_commit.subject)
+          end
+
+          # @param other [Avm::Git::Scms::Git::Commit]
+          # @return [Avm::Git::Scms::Git::Commit]
+          def merge_with(other)
+            validate_clean_and_head
+            raise 'Implemented for only if other is parent' unless
+            other.git_commit == git_commit.parent
+
+            git_scm.reset_and_commit(other.git_commit.parent, other.git_commit.raw_body)
+          end
+
+          def reword(new_message)
+            validate_clean_and_head
+
+            git_repo.command('commit', '--amend', '-m', new_message).execute!
+            self.class.new(git_scm, git_repo.head)
+          end
+
+          # @param path [Pathname]
+          # @return [TrueClass,FalseClass]
+          def scm_file?(path)
+            %w[.gitrepo .gitmodules].any? { |file| file.include?(path.basename.to_path) }
+          end
+
+          # @return [String]
+          delegate :subject, to: :git_commit
+
+          private
+
+          def validate_clean_and_head
+            raise 'Implemented for only if repository is no dirty' if git_repo.dirty?
+            raise 'Implemented for only if self is HEAD' unless
+            git_commit == git_repo.head
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/commit_dirty.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'avm/scms/commit_info'
+require 'avm/git/scms/git/changed_file'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class CommitDirty
+          enable_method_class
+          # @param commit_info [Avm::Scms::CommitInfo, nil]
+          common_constructor :scm, :commit_info, default: [nil]
+          delegate :git_repo, :head_commit, :run_commit, to: :scm
+
+          # @return [Avm::Git::Scms::Git::Commit,nil]
+          def result
+            return nil unless git_repo.dirty?
+
+            run_commit(asserted_commit_info)
+            head_commit
+          end
+
+          private
+
+          def asserted_commit_info
+            r = ::Avm::Scms::CommitInfo.assert(commit_info)
+            r = r.message(COMMIT_DIRTY_DEFAULT_MESSAGE) if r.message.blank?
+            git_repo.dirty_files.inject(r) { |a, e| a.path(e.absolute_path) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/commits.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        module Commits
+          # @return [Avm::Git::Scms::Git::Commit,nil]
+          def commit(source)
+            if source.is_a?(::Avm::Git::Scms::Git::Commit)
+              return source if source.git_repo == git_repo
+
+              raise 'Not same Git repository'
+            end
+            git_repo.commitize(source).if_present do |v|
+              ::Avm::Git::Scms::Git::Commit.new(self, v)
+            end
+          end
+
+          # @param commit_info [Avm::Scms::CommitInfo]
+          # @return [Avm::Git::Scms::Git::Commit,nil]
+          def commit_if_change(commit_info = nil)
+            tracker = ::Avm::Git::Scms::Git::ChangeTracker.new(self, commit_info)
+            tracker.start
+            yield
+            tracker.stop
+          end
+
+          # @return [Avm::Git::Scms::Git::Commit]
+          def head_commit
+            commit(git_repo.head)
+          end
+
+          # @param commit_info [Avm::Scms::CommitInfo]
+          # @return [Avm::Git::Scms::Git::Commit]
+          def reset_and_commit(commit_to_reset, commit_info)
+            git_repo.command('reset', '--soft', commit(commit_to_reset).git_commit.id).execute!
+            commit_dirty(commit_info)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/interval.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/scms/interval'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Interval < ::Avm::Scms::Interval
+          def initialize(scm, from, to)
+            super(scm, from, to)
+            self.from = scm.commit(from)
+            self.to = scm.commit(to)
+          end
+
+          # @return [Array<Avm::Git::Scms::Git::Commit>]
+          def commits
+            scm.git_repo.command('log', '--pretty=format:%H', git_commit_interval).execute!
+              .each_line.map { |sha1| scm.commit(sha1.strip) }
+          end
+
+          # @return [String]
+          def git_commit_interval
+            [from.id, to.id].join('..')
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/milestones.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'avm/scms/commit'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        module Milestones
+          BASE_COMMIT_REFERENCE = 'origin/master'
+
+          # @return [Avm::Git::Scms::Git::Commit]
+          def current_milestone_base_commit
+            commit(BASE_COMMIT_REFERENCE)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/remote.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'avm/scms/remote'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        class Remote < ::Avm::Scms::Remote
+          common_constructor :scm, :eac_git_remote
+
+          # @return [String]
+          def id
+            nyi eac_git_remote
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/scms/git/remotes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'avm/git/scms/git/remote'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Git
+    module Scms
+      class Git < ::Avm::Scms::Base
+        module Remotes
+          DEFAULT_REMOTE_ID = 'origin'
+
+          # @return [Avm::Git::Scms::Git::Remote]
+          def default_remote
+            remote(default_remote_id)
+          end
+
+          # @return [String]
+          def default_remote_id
+            DEFAULT_REMOTE_ID
+          end
+
+          # @param id [String]
+          # @return [Avm::Git::Scms::Git::Remote]
+          def remote(id)
+            ::Avm::Git::Scms::Git::Remote.new(self, git_repo.remote(id))
+          end
+        end
+      end
+    end
+  end
+end