eac_tools 0.101.0 → 0.101.1

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

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

@@ -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

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module Runners
-      class Base
-        class Subrepo
-          class Fix
-            runner_with :help do
-              desc 'Fix git-subrepos\' parent property.'
-            end
-
-            def run
-              loop do
-                break if fix
-
-                amend_each
-                rebase_fixup
-              end
-            end
-
-            private
-
-            def amend_each
-              infov 'Dirty files', local_repos.dirty_files.count
-              local_repos.dirty_files.each do |file|
-                infov '  * Ammending', file.path
-                ::Avm::Scms::AutoCommit::ForFile.new(
-                  git_scm, file.path,
-                  [::Avm::Scms::AutoCommit::Rules::Unique.new]
-                ).run
-              end
-            end
-
-            def fix
-              infom 'Checking/fixing...'
-              c = new_check(true)
-              c.show_result
-              !c.result.error?
-            end
-
-            # @return [Avm::Git::Scms::Git]
-            def git_scm_uncached
-              ::Avm::Git::Scms::Git.new(runner_context.call(:git).root_path)
-            end
-
-            def new_check(fix_parent = false) # rubocop:disable Style/OptionalBooleanParameter
-              r = ::Avm::Git::SubrepoChecks.new(local_repos).add_all_subrepos
-              r.fix_parent = fix_parent
-              r
-            end
-
-            def local_repos_uncached
-              ::EacGit::Local.new(runner_context.call(:git))
-            end
-
-            def rebase_fixup
-              local_repos.command('rebase', '-i', 'origin/master', '--autosquash').envvar(
-                'GIT_SEQUENCE_EDITOR', 'true'
-              ).or(
-                local_repos.command('rebase', '--continue').envvar('GIT_SEQUENCE_EDITOR', 'true')
-              ).system!
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module Runners
-      class Base
-        class Subrepo
-          require_sub __FILE__
-          runner_with :help, :subcommands do
-            desc 'Git-subrepo (https://github.com/ingydotnet/git-subrepo) utilities.'
-            subcommands
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module Runners
-      class Base
-        require_sub __FILE__
-        runner_with :help, :subcommands do
-          desc 'Git utilities for AVM.'
-          arg_opt '-C', '--path', 'Path to Git repository.'
-          subcommands
-        end
-
-        COMMAND_ARGUMENT = 'git'
-
-        # @return [String]
-        def self.command_argument
-          COMMAND_ARGUMENT
-        end
-
-        def repository_path
-          repository_path? ? parsed.path : '.'
-        end
-
-        def repository_path?
-          parsed.path.present?
-        end
-
-        def git
-          @git ||= ::Avm::Git::Launcher::Base.by_root(repository_path)
-        end
-
-        # @return [[EacGit::Local]]
-        def git_repo
-          git.eac_git
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-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