eac_tools 0.86.0 → 0.86.2

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Push
+          def dry_push_args
+            %w[push --dry-run] + [remote_name] + pushs
+          end
+
+          def dry_push_result
+            return ::Avm::Result.error('Nothing to push') if pushs.empty?
+
+            dry_push_execution_result
+          end
+
+          def push
+            if pushs.empty?
+              info 'PUSH: Nada a enviar'
+            else
+              info "PUSH: enviando \"#{pushs}\"..."
+              git_execute(%w[push origin] + pushs)
+            end
+          end
+
+          def pushs_uncached
+            [master_push, remove_branch_push, tag_push].compact
+          end
+
+          def master_push
+            remote_master_hash == branch_hash ? nil : "#{branch_hash}:refs/heads/master"
+          end
+
+          def remove_branch_push
+            remote_branch_hash ? ":refs/heads/#{branch.name}" : nil
+          end
+
+          def tag_push
+            return nil unless !remote_tag_hash || remote_tag_hash != branch_hash
+
+            "#{branch_hash}:#{tag}"
+          end
+
+          private
+
+          def dry_push_execution_result
+            r = launcher_git.execute(dry_push_args)
+            message = if r.fetch(:exit_code).zero?
+                        'ok'
+                      else
+                        r.fetch(:stderr) + "\n#{::Shellwords.join(dry_push_args)}"
+                      end
+            ::Avm::Result.success_or_error(r.fetch(:exit_code).zero?, message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Remote
+          def remote_master_hash
+            remote_hashs['refs/heads/master']
+          end
+
+          def remote_branch_hash
+            remote_hashs["refs/heads/#{branch.name}"]
+          end
+
+          def remote_tag_hash
+            remote_hashs[tag]
+          end
+
+          private
+
+          def remote_name
+            'origin'
+          end
+
+          def remote_hashs_uncached
+            launcher_git.remote_hashs(remote_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'avm/sources/configuration'
+require 'avm/result'
+require 'avm/sources/base'
+require 'avm/sources/tests/builder'
+require 'eac_ruby_utils/fs/temp'
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Test
+          def test_result
+            infom 'Running tests...'
+            test_performer.units.each do |single|
+              return ::Avm::Result.error(test_failed_result_message(single)) if single.failed?
+            end
+            ::Avm::Result.success('all passed')
+          end
+
+          private
+
+          def test_failed_result_message(single)
+            { 'Source' => single, 'STDOUT' => single.logs[:stdout],
+              'STDERR' => single.logs[:stderr] }.map { |k, v| "#{k}: #{v}" }.join(', ')
+          end
+
+          def test_performer
+            ::Avm::Sources::Tests::Builder
+              .new(::Avm::Registry.sources.detect(launcher_git))
+              .include_main(true)
+              .include_subs(true)
+              .performer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'clipboard'
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        module Tracker
+          def clipboard_copy_tracker_message
+            ::Clipboard.copy(textile_tracker_message)
+            infov 'Copied to clipboard', textile_tracker_message
+          end
+
+          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,39 @@
+# frozen_string_literal: true
+
+require 'avm/result'
+require 'eac_ruby_utils/core_ext'
+
+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,53 @@
+# frozen_string_literal: true
+
+require 'avm/git/issue/complete/validation'
+require 'avm/result'
+require 'ostruct'
+
+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
+
+          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
+
+require 'eac_cli/core_ext'
+require 'eac_git/local'
+
+module Avm
+  module Git
+    module Issue
+      class Complete
+        require_sub __FILE__, include_modules: true
+        enable_simple_cache
+        enable_speaker
+
+        BRANCH_NAME_ISSUE_ID_PATTERN =
+
+          attr_reader :dir, :skip_validations
+
+        def initialize(options)
+          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
+          @dir, @skip_validations = consumer.consume_all(:dir, :skip_validations)
+          validate_skip_validations
+          consumer.validate
+        end
+
+        def start_banner
+          validations_banner
+        end
+
+        def run
+          return false unless valid?
+
+          assert_tag
+          push
+          remove_local_branch
+          clipboard_copy_tracker_message
+          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,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+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,23 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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,40 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/git/launcher/remote'
+
+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,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+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,59 @@
+# frozen_string_literal: true
+
+require 'eac_git/executables'
+require 'eac_ruby_utils/envs'
+require 'git'
+require 'avm/launcher/paths/real'
+
+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,87 @@
+# frozen_string_literal: true
+
+require 'eac_git/local'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/envs'
+require 'avm/launcher/paths/real'
+require 'avm/git/launcher/error'
+
+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 :descendant?, :merge_base, :rev_parse, to: :eac_git
+
+        def initialize(path)
+          super(path)
+
+          @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,15 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/errors/base'
+
+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,38 @@
+# frozen_string_literal: true
+
+require 'avm/git/launcher/base'
+
+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