avm-tools 0.95.0 → 0.99.1

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 ::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

@@ -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

data/lib/eac_launcher/git/warp_base.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/git/mirror_update'
-require 'eac_launcher/vendor/github'
-require 'avm/projects/stereotypes/git/publish'
-
-module EacLauncher
-  module Git
-    # Métodos abstratos:
-    #  * source_instance
-    #  * source_remote_name
-    #  * current_ref
-    class WarpBase < ::EacLauncher::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
-        ::EacLauncher::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
-        ::EacLauncher::Git::Base.new(source_instance.real)
-      end
-
-      def cache_git_uncached
-        ::EacLauncher::Git::Base.new(update)
-      end
-
-      def target_remote_url
-        ::EacLauncher::Vendor::Github.to_ssh_url(source_git.git.remote(source_remote_name).url)
-      end
-    end
-  end
-end

data/lib/eac_launcher/instances/runner_helper.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/console/docopt_runner'
-require 'eac_ruby_utils/console/speaker'
-
-module EacLauncher
-  module Instances
-    class RunnerHelper < ::EacRubyUtils::Console::DocoptRunner
-      include ::EacRubyUtils::Console::Speaker
-
-      def context
-        @context ||= ::EacLauncher::Context.current
-      end
-
-      def find_instances(instance_name)
-        context.instances.select { |instance| instance_match?(instance, instance_name) }
-      end
-
-      def instance_match?(instance, instance_name)
-        ::File.fnmatch?(instance_name, instance.name)
-      end
-
-      def instances
-        if options['--all']
-          context.instances
-        elsif options['--pending']
-          context.pending_instances
-        else
-          options['<instance_path>'].flat_map { |p| find_instances(p) }
-        end
-      end
-
-      def instance_stereotypes(instance)
-        instance.stereotypes.map(&:label).join(', ')
-      end
-
-      def instance_label(instance)
-        "#{instance.name} [#{instance_stereotypes(instance)}]"
-      end
-    end
-  end
-end

data/lib/eac_launcher/paths.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_launcher/paths/logical'
-require 'eac_launcher/paths/real'

data/lib/eac_launcher/paths/logical.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'avm/projects/stereotypes'
-require 'eac_launcher/paths/real'
-
-module EacLauncher
-  module Paths
-    class Logical
-      include ::EacRubyUtils::SimpleCache
-
-      class << self
-        def from_h(context, hash)
-          parent_path = hash[:parent_path] ? from_h(context, hash[:parent_path]) : nil
-          new(context, parent_path, hash[:real], hash[:logical])
-        end
-      end
-
-      attr_reader :context, :real, :logical, :parent_path
-
-      def initialize(context, parent_path, real, logical)
-        @context = context
-        @parent_path = parent_path
-        @real = ::EacLauncher::Paths::Real.new(real)
-        @logical = logical
-      end
-
-      def to_s
-        logical
-      end
-
-      def to_h
-        { logical: logical, real: real.to_s, parent_path: parent_path ? parent_path.to_h : nil }
-      end
-
-      def project?
-        stereotypes.any?
-      end
-
-      def children
-        r = []
-        Dir.entries(warped).each do |c|
-          c_path = ::File.join(warped, c)
-          next unless ::File.directory?(c_path)
-          next if c.start_with?('.')
-
-          r << build_child(c)
-        end
-        r
-      end
-
-      def included?
-        !context.settings.excluded_paths.include?(logical)
-      end
-
-      private
-
-      def stereotypes_uncached
-        ::Avm::Projects::Stereotype.stereotypes.select { |s| s.match?(self) }
-      end
-
-      def build_child(name)
-        ::EacLauncher::Paths::Logical.new(
-          context,
-          self,
-          ::File.join(warped, name),
-          ::File.join(logical, name)
-        )
-      end
-
-      def warped_uncached
-        if is_a?(::Avm::Launcher::Instances::Base)
-          stereotypes.each do |s|
-            return s.warp_class.new(self) if s.warp_class
-          end
-        end
-        real
-      end
-    end
-  end
-end

data/lib/eac_launcher/paths/real.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module EacLauncher
-  module Paths
-    class Real < String
-      def initialize(path)
-        raise "Argument path is not a string: \"#{path}\"|#{path.class}" unless path.is_a?(String)
-
-        super(path)
-      end
-
-      def subpath(relative_path)
-        ::EacLauncher::Paths::Real.new(::File.expand_path(relative_path, self))
-      end
-
-      def basename
-        ::File.basename(self)
-      end
-
-      def dirname
-        return nil if self == '/'
-
-        self.class.new(::File.dirname(self))
-      end
-
-      def find_file_with_extension(extension)
-        r = find_files_with_extension(extension)
-        return r.first if r.any?
-
-        raise "Extension \"#{extension}\" not found in directory \"#{self}\""
-      end
-
-      def find_files_with_extension(extension)
-        r = []
-        ::Dir.entries(self).each do |i|
-          r << ::File.expand_path(i, self) if i =~ /#{::Regexp.quote(extension)}\z/
-        end
-        r
-      end
-    end
-  end
-end

data/lib/eac_launcher/project.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module EacLauncher
-  class Project
-    attr_reader :name, :instances
-
-    def initialize(name, instances)
-      @name = name
-      @instances = instances.to_a
-    end
-
-    def to_s
-      name
-    end
-  end
-end