avm-tools 0.99.0 → 0.99.1

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

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

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

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

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

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_git/executables'
-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)
-          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

data/lib/eac_launcher/git/error.rb

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

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/simple_cache'
-require 'eac_ruby_utils/simple_cache'
-require 'eac_launcher/publish/base'
-require 'eac_launcher/publish/check_result'
-
-module EacLauncher
-  module Git
-    class PublishBase < ::EacLauncher::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)
-
-        ::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

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/projects/stereotype'
-require 'avm/launcher/errors/base'
-
-module EacLauncher
-  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