eac_tools 0.99.1 → 0.101.0

data/sub/avm-git/lib/avm/git/launcher_stereotypes/git_subtree.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module LauncherStereotypes
+      class GitSubtree
+        require_sub __FILE__
+        include Avm::Launcher::Stereotype
+
+        class << self
+          def match?(path)
+            return false if other_git_stereotype?(path)
+            return false unless other_nogit_stereotype?(path)
+
+            parent = parent_git(path.parent_path)
+            return false unless parent
+
+            ::Git.open(parent.real).remote(path.real.basename).url ? true : false
+          end
+
+          def color
+            :green
+          end
+
+          def parent_git(parent_path)
+            return nil unless parent_path
+
+            if ::Avm::Git::LauncherStereotypes::Git.match?(parent_path)
+              parent_path
+            else
+              parent_git(parent_path.parent_path)
+            end
+          end
+
+          def other_git_stereotype?(path)
+            ::Avm::Git::LauncherStereotypes::Git.match?(path) ||
+              ::Avm::Git::LauncherStereotypes::GitSubrepo.match?(path)
+          end
+
+          def other_nogit_stereotype?(path)
+            Avm::Launcher::Stereotype.nogit_stereotypes.any? { |s| s.match?(path) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher_stereotypes/provider.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module LauncherStereotypes
+      class Provider
+        STEREOTYPES = [::Avm::Git::LauncherStereotypes::Git,
+                       ::Avm::Git::LauncherStereotypes::GitSubrepo,
+                       ::Avm::Git::LauncherStereotypes::GitSubtree].freeze
+
+        def all
+          STEREOTYPES
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module LauncherStereotypes
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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,74 @@
+# frozen_string_literal: true
+
+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-git/lib/avm/git/organize.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Organize
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+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 # rubocop:disable Naming/PredicateMethod
+        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/runners/base/commit.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Runners
+      class Base
+        class Commit
+          runner_with :help do
+            desc 'Mostra informações de um commit.'
+            bool_opt '-f', '--files', 'Mostra os arquivos.'
+            bool_opt '-s', '--size', 'Mostra o tamanho de arquivos.'
+            pos_arg :ref
+          end
+
+          def run
+            input_banner
+            validate
+            main_info_banner
+            files_banner
+            size_banner
+          end
+
+          private
+
+          def input_banner
+            infov 'Repository', git
+            infov 'Reference', reference
+          end
+
+          def validate
+            return if reference_id.present?
+
+            fatal_error "Object ID not found for reference \"#{reference}\""
+          end
+
+          def main_info_banner
+            infov 'Reference ID', reference_id
+            infov 'Subject', commit.subject
+            infov 'Author', commit.author_all
+            infov 'Commiter', commit.commiter_all
+            infov 'Files', commit.files.count
+          end
+
+          def size_banner
+            return unless show_size?
+
+            infov 'Total files size', bytes_size(commit.files_size)
+          end
+
+          def files_banner
+            return unless parsed.files?
+
+            commit.files.each do |file|
+              infov "  #{file.path}", file_value(file)
+            end
+          end
+
+          def file_value(file)
+            s = file.status
+            s += ", #{bytes_size(file.dst_size)}" if show_size?
+            s
+          end
+
+          def reference_id
+            git.rev_parse(reference)
+          end
+
+          def reference
+            parsed.ref
+          end
+
+          def git_uncached
+            ::Avm::Git::Launcher::Base.new(runner_context.call(:repository_path))
+          end
+
+          def commit_uncached
+            ::Avm::Git::Commit.new(git, reference_id)
+          end
+
+          def human_files_size
+            ::Filesize.from("#{commit.files_size} B").pretty
+          end
+
+          def bytes_size(size)
+            b = "#{size} B"
+            "#{::Filesize.from(b).pretty} (#{b})"
+          end
+
+          def show_size?
+            parsed.size?
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/runners/base/deploy.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Runners
+      class Base
+        class Deploy
+          DEFAULT_REFERENCE = 'HEAD'
+
+          runner_with :help do
+            desc 'Deploy a Git revision to a location (Local or remote).'
+            arg_opt '-a', '--append-dirs', 'Append directories to deploy (List separated by ":").'
+            arg_opt '-i', '--instance', 'Read entries from instance with id=<instance-id>.'
+            arg_opt '-r', '--reference', "Reference (default: #{DEFAULT_REFERENCE})."
+            pos_arg :target_url, optional: true
+          end
+
+          def run
+            input_banner
+            validate
+            main_info_banner
+            deploy
+            success 'Done'
+          end
+
+          private
+
+          def input_banner
+            infov 'Repository', git
+            infov 'Reference', reference
+            infov 'Instance ID', instance_id.if_present('- BLANK -')
+            infov 'Appended directories', appended_directories
+            infov 'Target URL', target_url
+          end
+
+          def validate
+            if reference_sha1.blank?
+              fatal_error "Object ID not found for reference \"#{reference}\""
+            end
+            fatal_error 'Nor <target-url> nor --instance was setted' if target_url.blank?
+          end
+
+          def main_info_banner
+            infov 'Reference SHA1', reference_sha1
+          end
+
+          def reference_sha1_uncached
+            git.git_repo.rev_parse(reference)
+          end
+
+          def reference
+            parsed.reference || DEFAULT_REFERENCE
+          end
+
+          def git_uncached
+            ::Avm::Git::Scms::Git.new(git_repository_path)
+          end
+
+          def git_repository_path
+            if runner_context.call(:repository_path) || dev_instance_fs_path.blank?
+              return runner_context.call(:repository_path)
+            end
+
+            dev_instance_fs_path
+          end
+
+          def dev_instance_fs_path
+            instance.if_present do |v|
+              v.application.instance('dev').read_entry_optional(
+                ::Avm::Instances::EntryKeys::INSTALL_PATH
+              )
+            end
+          end
+
+          def deploy
+            git.commit(reference_sha1)
+              .deploy_to_url(target_url)
+              .append_templatized_directories(appended_directories)
+              .variables_source_set(variables_source)
+              .run
+          end
+
+          def target_url
+            parsed.target_url.if_present { |v| return v }
+            instance.if_present { |v| return v.install_url }
+            nil
+          end
+
+          def variables_source
+            instance || ::EacConfig::Node.context.current
+          end
+
+          def instance_uncached
+            instance_id.if_present { |v| ::Avm::Instances::Base.by_id(v) }
+          end
+
+          def instance_id
+            parsed.instance
+          end
+
+          def appended_directories
+            parsed.append_dirs.to_s.split(':')
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/runners/base/dirty_files.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Runners
+      class Base
+        class DirtyFiles
+          DEFAULT_FORMAT = '%p'
+          FIELDS = {
+            i: :index, w: :worktree, p: :path, a: :absolute_path
+          }.transform_keys { |k| "%#{k}" }
+
+          runner_with :help do
+            desc 'Lists dirty files in Git repository.'
+            arg_opt '-f', '--format',
+                    "Format of each line (See \"Format fields\") [default: #{DEFAULT_FORMAT}]."
+          end
+
+          def help_extra_text
+            "Format fields:\n" + FIELDS.map { |k, v| "  #{k} => #{v}" }.join("\n") # rubocop:disable Style/StringConcatenation
+          end
+
+          def run
+            runner_context.call(:git).dirty_files.each do |file|
+              out("#{format_file(file)}\n")
+            end
+          end
+
+          private
+
+          def format
+            parsed.format || DEFAULT_FORMAT
+          end
+
+          def format_file(file)
+            FIELDS.inject(format) { |a, e| a.gsub(e.first, file.send(e.last)) }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/runners/base/organize.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Runners
+      class Base
+        class Organize
+          runner_with :help do
+            desc 'Organize branches.'
+            bool_opt '-a', '--all', 'Run all organizations.'
+            bool_opt '-n', '--no', 'Do not run operations.'
+            bool_opt '-o', '--originals', 'Remove refs/original branches.'
+            bool_opt '-s', '--subrepos', 'Remove git-subrepo branches.'
+            bool_opt '-y', '--yes', 'Run operations without confirmation.'
+          end
+
+          def run
+            start_banner
+            collect_references
+            after_collect_banner
+            run_operations
+          end
+
+          private
+
+          def after_collect_banner
+            infov 'Collected references', repository.collected_references.count
+            repository.collected_references.each do |ru|
+              infov "  * #{ru.reference}", ru.operation
+            end
+          end
+
+          def collect?(type)
+            parsed.fetch(type) || parsed.all?
+          end
+
+          def collect_references
+            %w[subrepos originals].each do |type|
+              repository.send("collect_#{type}") if collect?(type)
+            end
+          end
+
+          def run_operations
+            return warn('No operations to run (Run with --help to see options)') if
+            repository.collected_references.empty?
+            return unless run_operations?
+
+            repository.collected_references.each do |ru|
+              info "Doing operation #{ru}..."
+              ru.run_operation
+            end
+          end
+
+          def run_operations?
+            return true if parsed.yes?
+            return false if parsed.no?
+
+            input('Confirm operations?', bool: true)
+          end
+
+          def repository_uncached
+            ::Avm::Git::Organize::Repository.new(runner_context.call(:git).eac_git)
+          end
+
+          def start_banner
+            infov 'Repository', repository
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/runners/base/revisions_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Runners
+      class Base
+        class RevisionsTest
+          runner_with :help do
+            desc 'Test multiple revisions until a error is found.'
+            arg_opt '-c', '--command', 'Command to test instance.'
+            bool_opt '-n', '--no-cache', 'Does not use cache.'
+          end
+
+          def run
+            fatal_error('Repository is dirty') if runner_context.call(:git).dirty?
+
+            return_to_branch_on_end do
+              infov 'Revisions found', revisions.count
+              if revision_with_error
+                warn("First revision with error: #{revision_with_error}")
+              else
+                success('No error found in revisions')
+              end
+            end
+          end
+
+          private
+
+          def return_to_branch_on_end
+            current_branch = runner_context.call(:git).current_branch
+            yield
+          ensure
+            infom "Returning to original branch \"#{current_branch}\""
+            runner_context.call(:git).execute!('checkout', current_branch)
+          end
+
+          def revision_with_error_uncached
+            revision_with_error = nil
+            revisions.each do |revision|
+              revision.banner
+              unless revision.successful?
+                revision_with_error = revision
+                break
+              end
+            end
+            revision_with_error
+          end
+
+          def revisions_uncached
+            runner_context.call(:git).execute!('log', '--pretty=format:%H', 'origin/master..HEAD')
+              .each_line.map(&:strip).reverse.map do |sha1|
+              ::Avm::Git::RevisionTest.new(runner_context.call(:git), sha1, test_revision_options)
+            end
+          end
+
+          def test_revision_options
+            { test_command: parsed.command, no_cache: parsed.no_cache? }
+          end
+        end
+      end
+    end
+  end
+end