eac_tools 0.109.0 → 0.110.0

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

@@ -1,74 +0,0 @@
-# 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/revision_test.rb

@@ -1,102 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-require 'filesize'
-
-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

@@ -1,108 +0,0 @@
-# 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

@@ -1,42 +0,0 @@
-# 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

@@ -1,72 +0,0 @@
-# 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

@@ -1,63 +0,0 @@
-# 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

data/sub/avm-git/lib/avm/git/runners/base/subrepo/check.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module Runners
-      class Base
-        class Subrepo
-          class Check
-            runner_with :help do
-              desc 'Check status of subrepos.'
-              bool_opt '-a', '--all', 'Select all subrepos.'
-              bool_opt '-f', '--fix-parent', 'Fix parent SHA1.'
-              bool_opt '-n', '--no-error', 'Do not exit with error if check fails.'
-              bool_opt '-r', '--remote', 'Check subrepos remote.'
-              pos_arg :subrepos, repeat: true, optional: true
-            end
-
-            def run
-              subrepo_checks.show_result
-              return if parsed.no_error?
-              return unless subrepo_checks.result.error?
-
-              fatal_error 'Failed'
-            end
-
-            private
-
-            def subrepo_checks_uncached
-              r = ::Avm::Git::SubrepoChecks.new(local_repos)
-              r.check_remote = parsed.remote?
-              r.fix_parent = parsed.fix_parent?
-              r.add_all_subrepos if parsed.all?
-              r.add_subrepos(*parsed.subrepos)
-              r
-            end
-
-            def local_repos_uncached
-              ::EacGit::Local.new(runner_context.call(:git))
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/sub/avm-git/lib/avm/git/runners/base/subrepo/clone.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module Runners
-      class Base
-        class Subrepo
-          class Clone
-            runner_with :help do
-              desc 'Clone git-subrepo repositories.'
-              arg_opt '-b', '--branch', 'Branch.'
-              arg_opt '-d', '--parent-dir', 'Target path\'s parent directory.'
-              pos_arg :url
-              pos_arg :target_path, optional: true
-            end
-
-            def run
-              start_banner
-              clean
-              clone
-            end
-
-            private
-
-            def start_banner
-              infov 'URL', url
-              infov 'Subpath', target_path
-              infov 'Branch', branch
-            end
-
-            def clean
-              infom 'Cleaning...'
-              git.command('subrepo', 'clean', '--all', '--force').system!
-            end
-
-            def clone
-              infom 'Cloning...'
-              infov 'Clone arguments', clone_args
-              git.command(*clone_args).system!
-            end
-
-            delegate :branch, :url, to: :parsed
-
-            def git_uncached
-              ::EacGit::Local.new('.')
-            end
-
-            def clone_args
-              ['subrepo'] + branch.if_present([]) { |v| ['--branch', v] } +
-                if ::File.exist?(target_path)
-                  ['init', target_path, '--remote', url]
-                else
-                  ['clone', url, target_path, '--message', clone_message, '--force']
-                end
-            end
-
-            def clone_message
-              "Subrepo \"#{target_path}\" (#{url})."
-            end
-
-            def repos_name_from_url
-              %r{/([^/]+)\z}.if_match(url, false) { |m| m[1].gsub(/\.git\z/, '') }
-            end
-
-            def target_path
-              parsed.target_path || target_path_from_parent_dir ||
-                fatal_error('No target path specified')
-            end
-
-            def target_path_from_parent_dir
-              return nil unless parsed.parent_dir && repos_name_from_url
-
-              ::File.join(parsed.parent_dir, repos_name_from_url)
-            end
-          end
-        end
-      end
-    end
-  end
-end