avm-tools 0.45.0 → 0.50.0

data/lib/eac_launcher/instances.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/instances/base'
+require 'eac_launcher/instances/error'
+require 'eac_launcher/instances/runner_helper'
+require 'eac_launcher/instances/settings'

data/lib/eac_launcher/instances/base.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative 'base/cache'
+
+module EacLauncher
+  module Instances
+    module Base
+      class << self
+        def extend_object(object)
+          object.extend ::EacRubyUtils::SimpleCache
+          object.extend ::EacRubyUtils::Console::Speaker
+          object.extend ::EacLauncher::Instances::Base::Cache
+          super
+        end
+
+        def instanciate(path, parent)
+          unless path.is_a?(::EacLauncher::Instances::Base)
+            raise "#{path} is not a project" unless path.project?
+
+            path.extend(::EacLauncher::Instances::Base)
+            path.parent = parent
+          end
+          path
+        end
+      end
+
+      attr_accessor :parent
+
+      def name
+        logical
+      end
+
+      def stereotype?(stereotype)
+        stereotypes.include?(stereotype)
+      end
+
+      def to_parent_path
+        return self unless @parent
+
+        logical.gsub(/\A#{Regexp.quote(@parent.logical)}/, '')
+      end
+
+      def project?
+        stereotypes.any?
+      end
+
+      def publish_run
+        stereotypes.each do |s|
+          next unless publish?(s)
+
+          infov(name, "publishing #{s.stereotype_name_in_color}")
+          s.publish_class.new(self).run
+        end
+      end
+
+      def publish_check
+        stereotypes.each do |s|
+          next unless publish?(s)
+
+          puts "#{name.to_s.cyan}|#{s.stereotype_name_in_color}|" \
+            "#{s.publish_class.new(self).check}"
+        end
+      end
+
+      def project_name
+        ::File.basename(logical)
+      end
+
+      def included?
+        !::EacLauncher::Context.current.settings.excluded_projects.include?(project_name)
+      end
+
+      def to_h
+        super.to_h.merge(parent: parent ? parent.logical : nil)
+      end
+
+      private
+
+      def publish?(stereotype)
+        return false unless stereotype.publish_class
+
+        filter = ::EacLauncher::Context.current.publish_options[:stereotype]
+        filter.blank? ? true : filter == stereotype.name.demodulize
+      end
+
+      def options_uncached
+        ::EacLauncher::Context.current.settings.instance_settings(self)
+      end
+    end
+  end
+end

data/lib/eac_launcher/instances/base/cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EacLauncher
+  module Instances
+    module Base
+      module Cache
+        def cache_path(subpath)
+          File.join(cache_root, subpath)
+        end
+
+        def cache_key(key, &block)
+          v = cache_key_get(key)
+          return v if v.present? || block.nil?
+
+          v = yield
+          cache_key_write(key, v)
+          v
+        end
+
+        private
+
+        def cache_key_get(key)
+          File.file?(cache_key_path(key)) ? File.read(cache_key_path(key)) : nil
+        end
+
+        def cache_key_write(key, value)
+          FileUtils.mkdir_p(File.dirname(cache_key_path(key)))
+          File.write(cache_key_path(key), value)
+        end
+
+        def cache_key_path(key)
+          File.join(cache_root, 'keys', key.parameterize)
+        end
+
+        def cache_root
+          File.join(::EacLauncher::Context.current.cache_root, name.parameterize)
+        end
+      end
+    end
+  end
+end

data/lib/eac_launcher/instances/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacLauncher
+  module Instances
+    class Error < StandardError
+    end
+  end
+end

data/lib/eac_launcher/instances/runner_helper.rb

@@ -0,0 +1,42 @@
+# 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(&:stereotype_name_in_color).join(', ')
+      end
+
+      def instance_label(instance)
+        "#{instance.name} [#{instance_stereotypes(instance)}]"
+      end
+    end
+  end
+end

data/lib/eac_launcher/instances/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacLauncher
+  module Instances
+    class Settings
+      def initialize(data)
+        @data = ActiveSupport::HashWithIndifferentAccess.new(data.is_a?(Hash) ? data : {})
+      end
+
+      def git_current_revision
+        @data[__method__] || 'origin/master'
+      end
+
+      def git_publish_remote
+        @data[__method__] || 'publish'
+      end
+
+      def publishable?
+        @data.key?(:publishable) ? @data[:publishable] : true
+      end
+    end
+  end
+end

data/lib/eac_launcher/paths.rb

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

data/lib/eac_launcher/paths/logical.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/paths/real'
+require 'eac_launcher/stereotypes'
+
+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
+        ::EacLauncher::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?(::EacLauncher::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

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

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

data/lib/eac_launcher/publish.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/publish/base'
+require 'eac_launcher/publish/check_result'

data/lib/eac_launcher/publish/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'eac_launcher/instances/error'
+
+module EacLauncher
+  module Publish
+    class Base
+      attr_reader :instance
+
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def run
+        s = check
+        info("Check: #{s}")
+        return unless s.status == ::EacLauncher::Publish::CheckResult::STATUS_PENDING
+
+        publish
+      end
+
+      def check
+        s = check_with_rescue
+        ::EacLauncher::Context.current.instance_manager.publish_state_set(
+          instance, stereotype.stereotype_name, s.status
+        )
+        s
+      end
+
+      private
+
+      def stereotype
+        self.class.name.deconstantize.constantize
+      end
+
+      def check_with_rescue
+        internal_check
+      rescue ::EacLauncher::Instances::Error => e
+        ::EacLauncher::Publish::CheckResult.blocked("Error: #{e}")
+      rescue ::EacLauncher::Git::Error => e
+        ::EacLauncher::Publish::CheckResult.blocked("Git error: #{e}")
+      end
+    end
+  end
+end

data/lib/eac_launcher/publish/check_result.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/concern' # Missing on "eac/listable"
+require 'active_support/hash_with_indifferent_access'
+require 'eac_ruby_utils/listable'
+
+module EacLauncher
+  module Publish
+    class CheckResult
+      include ::EacRubyUtils::Listable
+
+      lists.add_string :status, :updated, :pending, :blocked, :outdated
+
+      lists.status.values.each do |status| # rubocop:disable Style/HashEachMethods
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def self.#{status}(message)
+            new('#{status}', message)
+          end
+        RUBY_EVAL
+      end
+
+      class << self
+        def pending_status?(status)
+          [STATUS_PENDING].include?(status)
+        end
+
+        def updated_color
+          'green'
+        end
+
+        def pending_color
+          'yellow'
+        end
+
+        def blocked_color
+          'red'
+        end
+
+        def outdated_color
+          'light_blue'
+        end
+      end
+
+      attr_reader :status, :message
+
+      def initialize(status, message)
+        raise "Status \"#{status}\" not in #{self.class.lists.status.values}" unless
+        self.class.lists.status.values.include?(status)
+
+        @status = status
+        @message = message
+      end
+
+      def to_s
+        message.light_white.send("on_#{background_color}")
+      end
+
+      private
+
+      def background_color
+        self.class.send("#{status}_color")
+      end
+    end
+  end
+end