eac_tools 0.102.0 → 0.102.1

data/sub/avm-git/lib/avm/git/issue/complete/tracker.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Tracker
+          private
+
+          def textile_tracker_message_uncached
+            "Revisado para commit:#{branch_short_hash}, ok."
+          end
+
+          def branch_short_hash
+            git_execute(['log', '--pretty=format:%h', '-1', '-q', branch_hash])
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/issue/complete/validation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        class Validation
+          enable_simple_cache
+          common_constructor :parent, :key, :label
+
+          SKIPPED_RESULT_MESSAGE = 'skipped'
+
+          def skip?
+            parent.skip_validations.include?(key)
+          end
+
+          private
+
+          def result_uncached
+            skip? ? skipped_result : validation_result
+          end
+
+          def skipped_result
+            ::Avm::Result.neutral(SKIPPED_RESULT_MESSAGE)
+          end
+
+          def validation_result
+            parent.send("#{key}_result")
+          rescue ::RuntimeError => e
+            ::Avm::Result.error("error raised: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/issue/complete/validations.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Validations
+          VALIDATIONS = {
+            clean_workspace: 'Clean workspace?',
+            branch_name: 'Branch name',
+            branch_hash: 'Branch hash',
+            follow_master: 'Follow master?',
+            commits: 'Commits?',
+            bifurcations: 'Bifurcations?',
+            dry_push: 'Dry push?',
+            git_subrepos: 'Git subrepos ok?',
+            test: 'Test ok?'
+          }.with_indifferent_access.freeze
+
+          def valid?
+            validations.map(&:result).none?(&:error?)
+          end
+
+          def validations_banner
+            validations.each do |v|
+              infov "[#{v.key}] #{v.label}", v.result.label
+            end
+          end
+
+          def validate_skip_validations
+            skip_validations.each do |validation|
+              next if VALIDATIONS.keys.include?(validation)
+
+              raise "\"#{validation}\" is not a registered validation"
+            end
+          end
+
+          # @return [Enumerable<String>]
+          def validation_keys
+            validations.map { |e| e.key.to_s.strip }.sort
+          end
+
+          private
+
+          def validations_uncached
+            VALIDATIONS.map do |key, label|
+              ::Avm::Git::Issue::Complete::Validation.new(self, key, label)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/issue/complete/working_tree.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module WorkingTree
+          def clean_workspace_result
+            ::Avm::Result.success_or_error(clean_workspace?, 'yes', 'no')
+          end
+
+          def clean_workspace?
+            launcher_git.dirty_files.none?
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/issue/complete.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        require_sub __FILE__, include_modules: true
+        enable_simple_cache
+        enable_speaker
+
+        attr_reader :scm, :skip_validations
+
+        def initialize(scm, options)
+          @scm = scm
+          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
+          @skip_validations = consumer.consume(:skip_validations)
+          validate_skip_validations
+          consumer.validate
+        end
+
+        # @return [String]
+        def dir
+          scm.path.to_path
+        end
+
+        def start_banner
+          validations_banner
+        end
+
+        def run # rubocop:disable Naming/PredicateMethod
+          return false unless valid?
+
+          assert_tag
+          push
+          remove_local_branch
+          true
+        end
+
+        def issue_id
+          branch ? issue_id_parser.parse(branch_name) : nil
+        end
+
+        # @return [EacRubyUtils::RegexpParser]
+        def issue_id_parser
+          /\A#{Regexp.quote('issue_')}(\d+)\z/.to_parser { |m| m[1].to_i }
+        end
+
+        private
+
+        # @return [EacGit::Local]
+        def eac_git_uncached
+          ::EacGit::Local.new(dir)
+        end
+
+        def git_execute(args, exit_outputs = {})
+          r = launcher_git.execute!(args, exit_outputs: exit_outputs)
+          r.is_a?(String) ? r.strip : r
+        end
+
+        def launcher_git_uncached
+          ::Avm::Git::Launcher::Base.new(dir)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+EacRubyUtils.require_sub(__FILE__)
+
+module Avm
+  module Git
+    module Issue
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/base/class_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        module ClassMethods
+          # @return [Avm::Git::Launcher::Base]
+          def by_root(search_base_path)
+            new(find_root(search_base_path).to_path)
+          end
+
+          # Searches the root path for the Git repository which includes +search_base_path+.
+          # @return [Pathname]
+          def find_root(search_base_path)
+            path = search_base_path.to_pathname.expand_path
+            loop do
+              return path if path.join('.git').exist?
+              raise "\".git\" not found for \"#{search_base_path}\"" if path.parent.root?
+
+              path = path.parent
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        module DirtyFiles
+          delegate :dirty?, to: :eac_git
+
+          # @return [Array<Struct>]
+          def dirty_files
+            eac_git.dirty_files.map do |df|
+              df.to_h.merge(path: df.path.to_path, absolute_path: df.absolute_path.to_path)
+                .to_struct
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/base/remotes.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        module Remotes
+          # @return [Avm::Git::Launcher::Remote]
+          def remote(name)
+            ::Avm::Git::Launcher::Remote.new(self, name)
+          end
+
+          def remote_hashs(remote_name)
+            remote(remote_name).ls
+          end
+
+          def remote_exist?(remote_name)
+            remote(remote_name).exist?
+          end
+
+          def assert_remote_url(remote_name, url)
+            r = git.remote(remote_name)
+            if !r.url || r.url != url
+              r.remove if r.url
+              git.add_remote(remote_name, url)
+            end
+            r
+          end
+
+          def remote_branch_sha(remote_name, branch_name)
+            remote_hashs(remote_name)["refs/heads/#{branch_name}"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        module Subrepo
+          def subrepo_status(subrepo_path)
+            s = execute!('subrepo', 'status', subrepo_path.gsub(%r{\A/}, ''))
+            raise s.strip.to_s if s.include?('is not a subrepo')
+
+            r = subrepo_status_parse_output(s)
+            raise "Empty subrepo status for |#{s}|\n" unless r.any?
+
+            r
+          end
+
+          def subrepo_remote_url(subrepo_path)
+            h = subrepo_status(subrepo_path)
+            url = h['Remote URL']
+            return url if url.present?
+
+            raise "Remote URL is blank for subrepo \"#{subrepo_path}\" (Subrepo status: #{h})"
+          end
+
+          private
+
+          def subrepo_status_parse_output(output)
+            r = {}.with_indifferent_access
+            output.each_line do |l|
+              m = /\A([^\:]+):(.*)\z/.match(l.strip)
+              next unless m && m[2].present?
+
+              r[m[1].strip] = m[2].strip
+            end
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/base/underlying.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        module Underlying
+          def command(*args)
+            args, options = build_args(args)
+            r = ::EacGit::Executables.git.command(*args)
+            (options[:exit_outputs] || {}).each do |status_code, result|
+              r = r.status_result(status_code, result)
+            end
+            r
+          end
+
+          %w[execute execute! system system!].each do |exec_type|
+            define_method exec_type do |*args|
+              command(*args).send(exec_type)
+            rescue ::EacRubyUtils::Envs::ExecutionError
+              raise ::Avm::Git::Launcher::Error
+            end
+          end
+
+          def init
+            git
+            self
+          end
+
+          private
+
+          def build_args(args)
+            options = {}
+            if args.last.is_a?(Hash)
+              options = args.last
+              args.pop
+            end
+            args = args.first if args.first.is_a?(Array)
+            [['-C', self, '--no-pager'] + args, options]
+          end
+
+          def git_uncached
+            FileUtils.mkdir_p(self)
+            if File.exist?(subpath('.git'))
+              ::Git.open(self)
+            else
+              ::Git.init(self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Base < ::Avm::Launcher::Paths::Real
+        require_sub __FILE__
+        enable_simple_cache
+        extend ::Avm::Git::Launcher::Base::ClassMethods
+        include ::Avm::Git::Launcher::Base::DirtyFiles
+        include ::Avm::Git::Launcher::Base::Remotes
+        include ::Avm::Git::Launcher::Base::Subrepo
+        include ::Avm::Git::Launcher::Base::Underlying
+
+        attr_reader :eac_git
+
+        delegate :merge_base, :rev_parse, to: :eac_git
+
+        def initialize(path)
+          super
+
+          @eac_git = ::EacGit::Local.new(path)
+        end
+
+        def init_bare
+          FileUtils.mkdir_p(self)
+          ::EacRubyUtils::Envs.local.command('git', 'init', '--bare', self).execute! unless
+          File.exist?(subpath('.git'))
+        end
+
+        # @return [Pathname]
+        def root_path
+          @root_path ||= self.class.find_root(to_s)
+        end
+
+        def descendant?(descendant, ancestor)
+          base = merge_base(descendant, ancestor)
+          return false if base.blank?
+
+          revparse = execute!('rev-parse', '--verify', ancestor).strip
+          base == revparse
+        end
+
+        def subtree_split(prefix)
+          execute!('subtree', '-q', 'split', '-P', prefix).strip
+        end
+
+        def push(remote_name, refspecs, options = {})
+          refspecs = [refspecs] unless refspecs.is_a?(Array)
+          args = ['push']
+          args << '--dry-run' if options[:dryrun]
+          args << '--force' if options[:force]
+          system!(args + [remote_name] + refspecs)
+        end
+
+        def push_all(remote_name)
+          system!('push', '--all', remote_name)
+          system!('push', '--tags', remote_name)
+        end
+
+        def fetch(remote_name, options = {})
+          args = ['fetch', '-p', remote_name]
+          args += %w[--tags --prune-tags --force] if options[:tags]
+          execute!(*args)
+        end
+
+        def current_branch
+          execute!(%w[symbolic-ref -q HEAD]).gsub(%r{\Arefs/heads/}, '').strip
+        end
+
+        def reset_hard(ref)
+          execute!('reset', '--hard', ref)
+        end
+
+        def raise(message)
+          ::Kernel.raise Avm::Git::Launcher::Error.new(self, message)
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class Error < ::Avm::Launcher::Errors::Base
+        def initialize(git_instance, message)
+          super("#{message} (Repository: #{git_instance})")
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/mirror_update.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class MirrorUpdate < ::Avm::Launcher::Paths::Real
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(target_path, source_path, source_rev)
+          super(target_path)
+          @target_git = ::Avm::Git::Launcher::Base.new(self)
+          @source_git = ::Avm::Git::Launcher::Base.new(source_path)
+          @source_rev = source_rev
+          run
+        end
+
+        private
+
+        def run
+          fetch_remote_source
+          reset_source_rev
+        end
+
+        def fetch_remote_source
+          @target_git.git
+          @target_git.assert_remote_url('origin', @source_git)
+          @target_git.fetch('origin', tags: true)
+        end
+
+        def reset_source_rev
+          @target_git.reset_hard(@source_git.rev_parse(@source_rev, true))
+        end
+      end
+    end
+  end
+end

data/sub/avm-git/lib/avm/git/launcher/publish_base.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Launcher
+      class PublishBase < ::Avm::Launcher::Publish::Base
+        include ::EacRubyUtils::SimpleCache
+        enable_speaker
+
+        CHECKERS = %w[remote_url remote_fetch publish_remote_no_exist remote_equal remote_following
+                      local_following].freeze
+
+        DEFAULT_REMOTE_REF = 'master'
+
+        REMOTE_UNAVAILABLE_MESSAGES = ['could not resolve host', 'connection timed out',
+                                       'no route to host'].map(&:downcase).freeze
+
+        protected
+
+        def internal_check
+          CHECKERS.each do |checker|
+            result = send("#{checker}_check_result")
+            return result if result
+          end
+          divergent_result_check_result
+        rescue ::Avm::Launcher::Instances::Error => e
+          ::Avm::Launcher::Publish::CheckResult.blocked(e.message)
+        rescue ::StandardError => e
+          raise e unless remote_unavailable_error?(e)
+
+          ::Avm::Launcher::Publish::CheckResult.blocked(e.message)
+        end
+
+        private
+
+        def remote_url_check_result
+          remote = sgit.remote(remote_name)
+          return if remote.exist? && remote.url.present?
+
+          ::Avm::Launcher::Publish::CheckResult.blocked("Remote \"#{remote_name}\" has blank path")
+        end
+
+        def remote_fetch_check_result
+          remote_fetch
+          nil
+        end
+
+        def remote_unavailable_error?(error)
+          error_message = error.message.downcase
+          REMOTE_UNAVAILABLE_MESSAGES.any? do |message|
+            error_message.include?(message)
+          end
+        end
+
+        def publish_remote_no_exist_check_result
+          return nil if sgit.remote_exist?(remote_name)
+
+          ::Avm::Launcher::Publish::CheckResult.blocked('Remote does not exist')
+        end
+
+        def remote_equal_check_result
+          return nil unless remote_sha.present? && remote_sha == local_sha
+
+          ::Avm::Launcher::Publish::CheckResult.updated('Remote equal')
+        end
+
+        def remote_following_check_result
+          return nil unless remote_sha.present? && sgit.descendant?(remote_sha, local_sha)
+
+          ::Avm::Launcher::Publish::CheckResult.outdated('Remote following')
+        end
+
+        def divergent_result_check_result
+          ::Avm::Launcher::Publish::CheckResult.blocked(
+            "Divergent (L: #{local_sha}, R: #{remote_sha})"
+          )
+        end
+
+        def local_following?
+          return true if remote_sha.blank?
+
+          sgit.descendant?(local_sha, remote_sha)
+        end
+
+        def local_following_check_result
+          return nil unless local_following?
+
+          ::Avm::Launcher::Publish::CheckResult.pending('Local following')
+        end
+
+        def sgit_uncached
+          ::Avm::Git::Launcher::Base.new(instance.warped)
+        end
+
+        def publish
+          info 'Pushing...'
+          sgit.push(remote_name, 'HEAD:master',
+                    dryrun: !::Avm::Launcher::Context.current.publish_options[:confirm])
+          info 'Pushed!'
+        end
+
+        def local_sha
+          sgit.git.object('HEAD').sha
+        end
+
+        def remote_sha_uncached
+          remote_fetch
+          b = sgit.git.branches["#{remote_name}/#{remote_ref}"]
+          b&.gcommit&.sha
+        end
+
+        def remote_fetch_uncached
+          sgit.fetch(remote_name)
+        end
+
+        def remote_name
+          ::Avm::Git::Launcher::WarpBase::TARGET_REMOTE
+        end
+
+        # @return [String]
+        def remote_ref
+          DEFAULT_REMOTE_REF
+        end
+      end
+    end
+  end
+end