avm-tools 0.99.0 → 0.99.1

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module DirtyFiles
+          delegate :dirty?, to: :eac_git
+
+          def dirty_files
+            eac_git.dirty_files.map do |df|
+              ::OpenStruct.new(
+                df.to_h.merge(path: df.path.to_path, absolute_path: df.absolute_path.to_path)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'avm/launcher/git/remote'
+
+module Avm
+  module Launcher
+    module Git
+      class Base < ::Avm::Launcher::Paths::Real
+        module Remotes
+          # @return [Avm::Launcher::Git::Remote]
+          def remote(name)
+            ::Avm::Launcher::Git::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/lib/avm/launcher/git/base/subrepo.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module Avm
+  module Launcher
+    module Git
+      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/lib/avm/launcher/git/base/underlying.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'eac_git/executables'
+require 'eac_ruby_utils/envs'
+require 'git'
+require 'avm/launcher/paths/real'
+
+module Avm
+  module Launcher
+    module Git
+      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
+
+          def execute(*args)
+            command(*args).execute
+          end
+
+          def execute!(*args)
+            command(*args).execute!
+          end
+
+          def system!(*args)
+            command(*args).system!
+          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/lib/avm/launcher/git/error.rb

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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/git/base'
+
+module Avm
+  module Launcher
+    module Git
+      class MirrorUpdate < ::Avm::Launcher::Paths::Real
+        include ::EacRubyUtils::SimpleCache
+
+        def initialize(target_path, source_path, source_rev)
+          super(target_path)
+          @target_git = ::Avm::Launcher::Git::Base.new(self)
+          @source_git = ::Avm::Launcher::Git::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/lib/avm/launcher/git/publish_base.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/simple_cache'
+require 'avm/launcher/publish/base'
+require 'avm/launcher/publish/check_result'
+
+module Avm
+  module Launcher
+    module Git
+      class PublishBase < ::Avm::Launcher::Publish::Base
+        include ::EacRubyUtils::SimpleCache
+        include ::EacCli::Speaker
+
+        CHECKERS = %w[remote_url remote_fetch publish_remote_no_exist remote_equal remote_following
+                      local_following].freeze
+
+        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 ::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
+          ::Avm::Launcher::Publish::CheckResult.pending('Local following')
+        end
+
+        def sgit_uncached
+          ::Avm::Launcher::Git::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}/master"]
+          b ? b.gcommit.sha : nil
+        end
+
+        def remote_fetch_uncached
+          sgit.fetch(remote_name)
+        end
+
+        def remote_name
+          ::Avm::Launcher::Git::WarpBase::TARGET_REMOTE
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/git/remote.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Launcher
+    module Git
+      class Remote
+        common_constructor :git, :name
+
+        def exist?
+          git.execute!('remote').each_line.any? { |line| line.strip == name }
+        end
+
+        def ls
+          git.execute!(['ls-remote', name]).each_line.map do |line|
+            x = line.strip.split(/\s+/)
+            [x[1], x[0]]
+          end.to_h
+        end
+
+        # +git remote add ...+
+        def add(url)
+          git.execute!('remote', 'add', name, url)
+        end
+
+        # +git remote rm ...+
+        def remove
+          git.execute!('remote', 'rm', name)
+        end
+
+        # +git remote get-url ...+
+        def url
+          git.execute!('remote', 'get-url', name).strip.if_present(nil)
+        end
+
+        # git remote set-url ...
+        def url_set(url)
+          git.execute!('remote', 'set-url', name, url)
+        end
+
+        # Add or set URL if +url+ is present, remove remote if is blank.
+        def url=(url)
+          if exist? && url.blank?
+            remove
+          elsif exist? && self.url != url
+            url_set(url)
+          elsif !exist?
+            add(url)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/git/sub_warp_base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'avm/projects/stereotype'
+require 'avm/launcher/errors/base'
+
+module Avm
+  module Launcher
+    module Git
+      module SubWarpBase
+        private
+
+        def parent_instance_uncached
+          r = find_parent_instance(instance.parent)
+          return r if r
+
+          ::Avm::Launcher::Errors::Base.new('Git parent not found')
+        end
+
+        def find_parent_instance(current)
+          if ::Avm::Projects::Stereotype.git_stereotypes.any? { |s| current.stereotype?(s) }
+            return current
+          end
+
+          current.parent ? find_parent_instance(current.parent) : nil
+        end
+
+        def to_parent_git_path
+          instance.logical.gsub(%r{\A#{Regexp.quote(parent_instance.logical)}/}, '')
+        end
+      end
+    end
+  end
+end

data/lib/avm/launcher/git/warp_base.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/git/mirror_update'
+require 'avm/launcher/vendor/github'
+require 'avm/projects/stereotypes/git/publish'
+
+module Avm
+  module Launcher
+    module Git
+      # Métodos abstratos:
+      #  * source_instance
+      #  * source_remote_name
+      #  * current_ref
+      class WarpBase < ::Avm::Launcher::Paths::Real
+        include ::EacRubyUtils::SimpleCache
+
+        TARGET_REMOTE = ::Avm::Projects::Stereotypes::Git::Publish::PUBLISH_GIT_REMOTE_NAME
+
+        def initialize(instance)
+          @instance = instance
+          cache_git.git.reset_hard(current_ref)
+          cache_git.remote(TARGET_REMOTE).url = target_remote_url
+          super(path)
+        end
+
+        protected
+
+        attr_reader :instance
+
+        def update
+          ::Avm::Launcher::Git::MirrorUpdate.new(
+            path,
+            source_instance.real,
+            source_instance.options.git_current_revision
+          )
+        end
+
+        def path
+          instance.cache_path('git_repository')
+        end
+
+        def source_git_uncached
+          ::Avm::Launcher::Git::Base.new(source_instance.real)
+        end
+
+        def cache_git_uncached
+          ::Avm::Launcher::Git::Base.new(update)
+        end
+
+        def target_remote_url
+          ::Avm::Launcher::Vendor::Github.to_ssh_url(source_git.git.remote(source_remote_name).url)
+        end
+      end
+    end
+  end
+end