avm-tools 0.44.2 → 0.49.0

data/lib/eac_launcher/git/base/class_methods.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      module ClassMethods
+        # @return [EacLauncher::Git::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

data/lib/eac_launcher/git/base/dirty_files.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      module DirtyFiles
+        def dirty?
+          dirty_files.any?
+        end
+
+        def dirty_files
+          execute!('status', '--porcelain', '--untracked-files').each_line.map do |line|
+            parse_status_line(line.gsub(/\n\z/, ''))
+          end
+        end
+
+        private
+
+        def parse_status_line(line)
+          m = /\A(.)(.)\s(.+)\z/.match(line)
+          ::Kernel.raise "Status pattern does not match \"#{line}\"" unless m
+          ::OpenStruct.new(index: m[1], worktree: m[2], path: m[3],
+                           absolute_path: ::File.expand_path(m[3], self))
+        end
+      end
+    end
+  end
+end

data/lib/eac_launcher/git/base/remotes.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_launcher/git/remote'
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      module Remotes
+        # @return [EacLauncher::Git::Remote]
+        def remote(name)
+          ::EacLauncher::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

data/lib/eac_launcher/git/base/subrepo.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::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

data/lib/eac_launcher/git/base/underlying.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs'
+require 'git'
+require 'eac_launcher/paths/real'
+
+module EacLauncher
+  module Git
+    class Base < ::EacLauncher::Paths::Real
+      module Underlying
+        def command(*args)
+          args, _options = build_args(args)
+          ::EacRubyUtils::Envs.local.command(*args)
+        end
+
+        def execute(*args)
+          args, options = build_args(args)
+          ::EacRubyUtils::Envs.local.command(*args).execute(options)
+        end
+
+        def execute!(*args)
+          args, options = build_args(args)
+          ::EacRubyUtils::Envs.local.command(*args).execute!(options)
+        end
+
+        def system!(*args)
+          args, options = build_args(args)
+          ::EacRubyUtils::Envs.local.command(*args).system!(options)
+        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)
+          [['git', '-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

data/lib/eac_launcher/git/error.rb

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

data/lib/eac_launcher/git/mirror_update.rb

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

data/lib/eac_launcher/git/publish_base.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_launcher/publish/base'
+
+module EacLauncher
+  module Git
+    class PublishBase < ::EacLauncher::Publish::Base
+      include ::EacRubyUtils::SimpleCache
+      include ::EacRubyUtils::Console::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)
+
+        ::EacLauncher::Publish::CheckResult.blocked(e.message)
+      end
+
+      private
+
+      def remote_url_check_result
+        remote = sgit.remote(remote_name)
+        return if remote.exist? && remote.url.present?
+
+        ::EacLauncher::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)
+
+        ::EacLauncher::Publish::CheckResult.blocked('Remote does not exist')
+      end
+
+      def remote_equal_check_result
+        return nil unless remote_sha.present? && remote_sha == local_sha
+
+        ::EacLauncher::Publish::CheckResult.updated('Remote equal')
+      end
+
+      def remote_following_check_result
+        return nil unless remote_sha.present? && sgit.descendant?(remote_sha, local_sha)
+
+        ::EacLauncher::Publish::CheckResult.outdated('Remote following')
+      end
+
+      def divergent_result_check_result
+        ::EacLauncher::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
+        ::EacLauncher::Publish::CheckResult.pending('Local following')
+      end
+
+      def sgit_uncached
+        ::EacLauncher::Git::Base.new(instance.warped)
+      end
+
+      def publish
+        info 'Pushing...'
+        sgit.push(remote_name, 'HEAD:master',
+                  dryrun: !::EacLauncher::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
+        ::EacLauncher::Git::WarpBase::TARGET_REMOTE
+      end
+    end
+  end
+end

data/lib/eac_launcher/git/remote.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacLauncher
+  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

data/lib/eac_launcher/git/sub_warp_base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/instances/error'
+
+module EacLauncher
+  module Git
+    module SubWarpBase
+      private
+
+      def parent_instance_uncached
+        r = find_parent_instance(instance.parent)
+        return r if r
+
+        ::EacLauncher::Instances::Error.new('Git parent not found')
+      end
+
+      def find_parent_instance(current)
+        if ::EacLauncher::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