eac_tools 0.102.1 → 0.103.1

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module LauncherStereotypes
-      class GitSubrepo
-        class Warp < ::Avm::Launcher::Paths::Real
-          include ::Avm::Git::Launcher::SubWarpBase
-          include ::EacRubyUtils::SimpleCache
-
-          attr_reader :instance
-
-          def initialize(instance)
-            @instance = instance
-            check_parent
-            init_aux
-            push_to_aux
-            reset
-            assert_target_remote
-            super(warped_git)
-          end
-
-          private
-
-          def check_parent
-            return if parent_git_warped.rev_parse(subrepo_parent_hash) &&
-                      parent_git_warped.descendant?('HEAD', subrepo_parent_hash)
-
-            raise Avm::Launcher::Errors::Base,
-                  "Subrepo parent hash \"#{subrepo_parent_hash}\" " \
-                  "not found in \"#{parent_git_warped}\""
-          end
-
-          def subrepo_parent_hash
-            data = parent_git_warped.subrepo_status(to_parent_git_path)
-            h = data['Pull Parent']
-            return h if h.present?
-
-            raise Avm::Launcher::Errors::Base, "Subrepo parent hash is blank: #{data}"
-          end
-
-          def init_aux
-            ::Avm::Git::Launcher::Base.new(aux_path).init_bare
-          end
-
-          def parent_git_warped_uncached
-            ::Avm::Git::Launcher::Base.new(parent_instance.warped)
-          end
-
-          def aux_path
-            instance.cache_path('subrepo_aux_git_repository')
-          end
-
-          def warped_git_uncached
-            ::Avm::Git::Launcher::Base.new(instance.cache_path('git_repository'))
-          end
-
-          def push_to_aux
-            parent_git_warped.execute!('subrepo', 'branch', to_parent_git_path, '-fF')
-            h = parent_git_warped.rev_parse("subrepo/#{to_parent_git_path}", true)
-            parent_git_warped.execute!('push', aux_path, "#{h}:refs/heads/master", '--force')
-          end
-
-          def reset
-            ::Avm::Git::Launcher::MirrorUpdate.new(warped_git, aux_path, 'master')
-          end
-
-          def assert_target_remote
-            warped_git.assert_remote_url(::Avm::Git::Launcher::WarpBase::TARGET_REMOTE,
-                                         target_remote_url)
-          end
-
-          def target_remote_url
-            ::Avm::Git::Vendor::Github.to_ssh_url(
-              parent_git_warped.subrepo_remote_url(to_parent_git_path)
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module LauncherStereotypes
-      class GitSubrepo
-        require_sub __FILE__
-        include Avm::Launcher::Stereotype
-
-        CONFIG_SUBPATH = '.gitrepo'
-
-        class << self
-          def match?(path)
-            File.exist?(path.real.subpath(CONFIG_SUBPATH)) && subrepo_url(path.real) != 'none'
-          end
-
-          def color
-            :light_cyan
-          end
-
-          def subrepo_url(path)
-            File.read(path.subpath(CONFIG_SUBPATH)).each_line do |l|
-              m = /remote\s*=\s(.+)/.match(l)
-              return m[1] if m
-            end
-            raise ::Avm::Git::Launcher::Error.new(path, '"remote = ... " not found')
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module LauncherStereotypes
-      class GitSubtree
-        class Publish < ::Avm::Git::Launcher::PublishBase
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Avm
-  module Git
-    module LauncherStereotypes
-      class GitSubtree
-        class Warp < ::Avm::Git::Launcher::WarpBase
-          include ::Avm::Git::Launcher::SubWarpBase
-
-          private
-
-          def current_ref
-            instance.cache_key("git_subtree.parent.#{cache_git.git.object('HEAD').sha}") do
-              cache_git.subtree_split(to_parent_git_path)
-            end
-          end
-
-          def source_instance
-            parent_instance
-          end
-
-          def source_remote_name
-            instance.project_name
-          end
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,17 +0,0 @@
-# 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/organize/reference_update.rb

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

@@ -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/organize.rb

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

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