eac_tools 0.115.0 → 0.116.0

data/sub/avm/lib/avm/launcher/publish/check_result.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_support/concern' # Missing on "eac/listable"
+require 'active_support/hash_with_indifferent_access'
+
+module Avm
+  module Launcher
+    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
+          singleton_class.define_method status do |message|
+            new(status, message)
+          end
+        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
+end

data/sub/avm/lib/avm/launcher/stereotype.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'colorized_string'
+
+module Avm
+  module Launcher
+    module Stereotype
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+        end
+
+        def git_stereotypes
+          stereotypes.select { |c| c.name.demodulize.downcase.match('git') }
+        end
+
+        def nogit_stereotypes
+          stereotypes - git_stereotypes
+        end
+
+        def stereotypes
+          ::Avm::Registry.launcher_stereotypes.available
+        end
+      end
+
+      module ClassMethods
+        def label
+          ::ColorizedString.new(stereotype_name).send(color)
+        end
+
+        def stereotype_name
+          name.demodulize
+        end
+
+        {
+          local_project_mixin: ::Module,
+          publish: ::Class,
+          update: ::Class,
+          version_bump: ::Class,
+          warp: ::Class
+        }.each do |name, is_a|
+          define_method "#{name}_#{is_a.name.underscore}" do
+            sub_constant(name.to_s.camelcase, is_a)
+          end
+        end
+
+        private
+
+        def sub_constant(constant_name, is_a)
+          return nil unless const_defined?(constant_name)
+
+          constant = const_get(constant_name)
+          unless is_a.if_present(true) { |v| constant.is_a?(v) }
+            raise("#{constant} is not a #{is_a}")
+          end
+
+          constant
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/patches/eac_config/entry_path.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module EacConfig
+  class EntryPath
+    # @return [Symbol]
+    def auto_method_name
+      method_name('auto_', '')
+    end
+
+    # @return [Symbol]
+    def default_method_name
+      method_name('', '_default_value')
+    end
+
+    # @return [Symbol]
+    def get_method_name # rubocop:disable Naming/AccessorMethodName
+      method_name('', '')
+    end
+
+    # @return [Symbol]
+    def get_optional_method_name # rubocop:disable Naming/AccessorMethodName
+      method_name('', '_optional')
+    end
+
+    # @return [Symbol]
+    def inherited_block_method_name
+      method_name('', '_inherited_value_proc')
+    end
+
+    # @return [String]
+    def variableize
+      parts.join('_')
+    end
+
+    private
+
+    # @param before [String]
+    # @param after [String]
+    # @return [Symbol]
+    def method_name(before, after)
+      :"#{before}#{variableize}#{after}"
+    end
+  end
+end

data/sub/avm/lib/avm/path_string.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+module Avm
+  # String with paths like PATH variable.
+  # Note: the separator is not system dependent.
+  class PathString < String
+    SEPARATOR = ':'
+
+    class << self
+      # Shortcut for [Avm::Paths.new(string).paths].
+      def paths(string)
+        new(string).paths
+      end
+    end
+
+    def initialize(string = nil)
+      super(string.to_s)
+    end
+
+    # @return [Array] List of paths. Blank paths are rejected.
+    def paths
+      split(SEPARATOR).compact_blank
+    end
+  end
+end

data/sub/avm/lib/avm/registry/application_scms.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class ApplicationScms < ::Avm::Registry::FromGems
+      def class_detect(klass, detect_args)
+        return nil unless klass.type_name == detect_args.fetch(0).scm_type
+
+        klass.new(*detect_args)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/application_stereotypes/build_available.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class ApplicationStereotypes
+      class BuildAvailable
+        enable_method_class
+
+        common_constructor :owner
+
+        def result
+          reset_buffer
+          read_registries
+          buffer.values.map(&:build)
+        end
+
+        private
+
+        attr_accessor :buffer
+
+        def read_object(type, object)
+          buffer[object.stereotype_namespace_module] ||=
+            ::Avm::Registry::ApplicationStereotypes::StereotypeBuilder
+              .new(object.stereotype_namespace_module)
+          buffer[object.stereotype_namespace_module].add_object(type, object)
+        end
+
+        def read_registries
+          ::Avm::ApplicationStereotypes::Base.lists.resource.each_value do |resource|
+            read_registry(resource)
+          end
+        end
+
+        def read_registry(resource)
+          ::Avm::Registry.send(resource.to_s.pluralize).available
+            .each { |obj| read_object(resource, obj) }
+        end
+
+        def reset_buffer
+          self.buffer = {}
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/application_stereotypes/stereotype_builder.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class ApplicationStereotypes
+      class StereotypeBuilder
+        common_constructor :namespace_module
+
+        def add_object(type, object)
+          type = type.to_sym
+          raise "#{attr_method} is already present" if resources.key?(type)
+
+          resources[::Avm::ApplicationStereotypes::Base.lists.resource.value_validate!(type)] =
+            object
+        end
+
+        # @return [Avm::ApplicationStereotypes::Base]
+        def build
+          ::Avm::ApplicationStereotypes::Base.new(namespace_module, resources)
+        end
+
+        private
+
+        def resources
+          @resources ||= {}
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/application_stereotypes.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class ApplicationStereotypes < ::Avm::Registry::Base
+      require_sub __FILE__, require_dependency: true
+      enable_simple_cache
+
+      def available
+        @available ||= build_available
+      end
+
+      def detect(obj)
+        detect_optional(obj) || raise_not_found(obj)
+      end
+
+      def detect_optional(obj)
+        detect_by_instance_class(obj) || detect_by_source_class(obj) || detecy_by_name(obj)
+      end
+
+      private
+
+      def detect_by_instance_class(obj)
+        return nil unless obj.is_a?(::Class) && obj < ::Avm::Instances::Base
+
+        available.find { |a| a.instance_class == obj }
+      end
+
+      def detecy_by_name(obj)
+        return nil unless obj.is_a?(::String)
+
+        available.find { |a| a.name == obj }
+      end
+
+      def detect_by_source_class(obj)
+        return nil unless obj.is_a?(::Class) && obj < ::Avm::Sources::Base
+
+        available.find { |a| a.source_class == obj }
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/applications.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Applications
+      def initialize(*args); end
+
+      # @return [Array<Avm::Applications::Base>]
+      def available
+        load_config
+        detected.values
+      end
+
+      # @return [Avm::Applications::Base]
+      def detect(id)
+        id = id.to_s
+        detected[id] = ::Avm::Applications::Base.new(id) unless detected.key?(id)
+        detected[id]
+      end
+
+      private
+
+      # @return [Hash<String, Avm::Applications::Base>]
+      def detected
+        @detected ||= {}
+      end
+
+      def load_config
+        ::Avm::Registry.config_objects.available.each do |id, type|
+          detect(id) if type == ::Avm::Applications::Base::AVM_TYPE
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Base
+      acts_as_abstract
+      common_constructor :module_suffix
+
+      def available
+        raise_abstract __method__
+      end
+
+      def to_s
+        "#{self.class}[#{module_suffix}]"
+      end
+
+      private
+
+      def raise_not_found(*args)
+        raise(::Avm::Registry::DetectionError,
+              "No registered module valid for #{args} " \
+              "(Module suffix: #{module_suffix}, Available: #{available.join(', ')})")
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/config_objects.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class ConfigObjects
+      def initialize(*args); end
+
+      # @return [Array<Avm::Applications::Base>]
+      def available
+        ::EacConfig::Node.context.current.entries('*.avm_type').node_entries
+          .map { |ne| [ne.path.first, ne.value] }
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/detection_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class DetectionError < RuntimeError
+    end
+  end
+end

data/sub/avm/lib/avm/registry/file_formats.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class FileFormats < ::Avm::Registry::FromGems
+      # @return [Avm::FileFormats::Base]
+      def class_detect(klass, detect_args)
+        klass.new if klass.new.match?(detect_args.first)
+      end
+
+      # @return [Avm::FileFormats::Base, Avm::FileFormats::Unknown]
+      def detect_optional(*registered_initialize_args)
+        super || ::Avm::FileFormats::Unknown.new
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/from_gems.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class FromGems < ::Avm::Registry::Base
+      enable_abstract_methods
+      enable_simple_cache
+
+      def available
+        registered_modules.reject(&:abstract?)
+      end
+
+      def class_detect(_klass, _detect_args)
+        raise_abstract_method __method__
+      end
+
+      def detect(*registered_initialize_args)
+        detect_optional(*registered_initialize_args) ||
+          raise_not_found(*registered_initialize_args)
+      end
+
+      def detect_optional(*registered_initialize_args)
+        available.reverse.lazy
+          .map { |klass| class_detect(klass, registered_initialize_args) }.find(&:present?)
+      end
+
+      def provider_module_suffix
+        "#{module_suffix}::Provider"
+      end
+
+      def single_module_suffix
+        "#{module_suffix}::Base"
+      end
+
+      def valid_registered_module?(a_module)
+        a_module.is_a?(::Class) && !a_module.abstract?
+      end
+
+      private
+
+      def registered_modules_uncached
+        registered_gems.flat_map { |registry| modules_from_registry(registry) }
+          .select { |v| valid_registered_module?(v) }.uniq
+      end
+
+      def modules_from_registry(registry)
+        if registry.registry.module_suffix == provider_module_suffix
+          registry.registered_module.new.all
+        else
+          [registry.registered_module]
+        end
+      end
+
+      def registered_gems
+        (single_instance_registry.registered + provider_registry.registered).sort
+      end
+
+      def single_instance_registry_uncached
+        ::EacRubyUtils::GemsRegistry.new(single_module_suffix)
+      end
+
+      def provider_registry_uncached
+        ::EacRubyUtils::GemsRegistry.new(provider_module_suffix)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/instances.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Instances < ::Avm::Registry::FromGems
+      # @return [Avm::Instances::Base, nil]
+      def class_detect(klass, detect_args)
+        r = ::Avm::Instances::Base.by_id(*detect_args)
+        r.application.stereotype.instance_class == klass ? klass.by_id(*detect_args) : nil
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/launcher_stereotypes.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class LauncherStereotypes < ::Avm::Registry::WithPath
+    end
+  end
+end

data/sub/avm/lib/avm/registry/runners.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Runners < ::Avm::Registry::FromGems
+    end
+  end
+end

data/sub/avm/lib/avm/registry/scms.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Scms < ::Avm::Registry::WithPath
+    end
+  end
+end

data/sub/avm/lib/avm/registry/source_generators.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class SourceGenerators < ::Avm::Registry::FromGems
+      # @return [Avm::Instances::Base, nil]
+      def class_detect(klass, detect_args)
+        detect_args = detect_args.dup
+        stereotype_name = detect_args.shift
+        klass.application_stereotype.name == stereotype_name ? klass.new(*detect_args) : nil
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/sources.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class Sources < ::Avm::Registry::WithPath
+      # @return [Avm::ApplicationStereotypes::Base]
+      def application_stereotype_by_name(name)
+        ::Avm::Registry.application_stereotypes.detect(name)
+      end
+
+      # @return [Avm::Sources::Base, nil]
+      def detect_optional(*detect_args)
+        detect_optional_by_configuration(*detect_args) ||
+          detect_optional_by_application_configuration(*detect_args) ||
+          super
+      end
+
+      # @return [Avm::Sources::Base, nil]
+      def detect_optional_by_application_configuration(path, *detect_args)
+        ::Avm::Sources::Base.new(path).application.stereotype_by_configuration.if_present do |v|
+          v.source_class.new(path, *detect_args)
+        end
+      end
+
+      # @return [Avm::Sources::Base, nil]
+      def detect_optional_by_configuration(path, *detect_args)
+        source_configured_stereotype_name(path).if_present do |v|
+          application_stereotype_by_name(v).source_class.new(path, *detect_args)
+        end
+      end
+
+      # @return [String]
+      def source_configured_stereotype_name(path)
+        ::Avm::Sources::Base.new(path).stereotype_name_by_configuration
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/with_path/cache.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class WithPath < ::Avm::Registry::FromGems
+      class Cache
+        enable_simple_cache
+        common_constructor :owner
+
+        def detect_optional(path)
+          return nil if path.root?
+          return cached_paths.fetch(path) if cached_paths.key?(path)
+
+          detected = owner.detect_optional(path)
+          detected = detect_optional(path.parent) if detected.blank?
+          cached_paths[path] = detected
+          detected
+        end
+
+        private
+
+        def cached_paths_uncached
+          {}
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/registry/with_path.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Avm
+  module Registry
+    class WithPath < ::Avm::Registry::FromGems
+      # @return [Object, nil]
+      def class_detect(klass, detect_args)
+        r = klass.new(*detect_args)
+        r.valid? ? r : nil
+      end
+
+      def detect_by_path(path)
+        detect_by_path_optional(path) || raise_not_found(path)
+      end
+
+      def detect_by_path_optional(path)
+        on_cache do
+          cache.detect_optional(path)
+        end
+      end
+
+      private
+
+      attr_accessor :cache
+
+      def on_cache(&)
+        cache.present? ? on_cache_with_cache(&) : on_cache_with_no_cache(&)
+      end
+
+      def on_cache_with_cache(&block)
+        block.call
+      end
+
+      def on_cache_with_no_cache(&block)
+        self.cache = ::Avm::Registry::WithPath::Cache.new(self)
+        begin
+          block.call
+        ensure
+          self.cache = nil
+        end
+      end
+    end
+  end
+end