eac_tools 0.97.2 → 0.98.0

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,15 @@
+# frozen_string_literal: true
+
+require 'avm/registry/from_gems'
+
+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,49 @@
+# frozen_string_literal: true
+
+require 'avm/application_stereotypes/base'
+require 'avm/registry/application_stereotypes/stereotype_builder'
+require 'eac_ruby_utils/core_ext'
+
+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,33 @@
+# frozen_string_literal: true
+
+require 'avm/application_stereotypes/base'
+require 'eac_ruby_utils/core_ext'
+
+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,52 @@
+# frozen_string_literal: true
+
+require 'avm/instances/base'
+require 'avm/sources/base'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Registry
+    class ApplicationStereotypes
+      require_sub __FILE__, require_dependency: true
+      enable_simple_cache
+
+      common_constructor :module_suffix
+
+      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 available_uncached
+        build_available
+      end
+
+      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
+
+      def raise_not_found(obj)
+        raise("No registered module valid for #{obj} (Available: #{available.join(', ')})")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'avm/applications/base'
+require 'eac_ruby_utils/core_ext'
+
+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/config_objects.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'avm/applications/base'
+require 'eac_ruby_utils/core_ext'
+
+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/file_formats.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'avm/file_formats/unknown'
+require 'avm/registry/from_gems'
+
+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,80 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/gems_registry'
+
+module Avm
+  module Registry
+    class FromGems
+      enable_abstract_methods
+      enable_simple_cache
+      common_constructor :module_suffix
+
+      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 to_s
+        "#{self.class}[#{module_suffix}]"
+      end
+
+      def valid_registered_module?(a_module)
+        a_module.is_a?(::Class) && !a_module.abstract?
+      end
+
+      private
+
+      def raise_not_found(*args)
+        raise("No registered module valid for #{args} " \
+              "(Module suffix: #{module_suffix}, Available: #{available.join(', ')})")
+      end
+
+      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,16 @@
+# frozen_string_literal: true
+
+require 'avm/instances/base'
+require 'avm/registry/from_gems'
+
+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,11 @@
+# frozen_string_literal: true
+
+require 'avm/registry/with_path'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Registry
+    class LauncherStereotypes < ::Avm::Registry::WithPath
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'avm/registry/from_gems'
+
+module Avm
+  module Registry
+    class Runners < ::Avm::Registry::FromGems
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'avm/registry/with_path'
+
+module Avm
+  module Registry
+    class Scms < ::Avm::Registry::WithPath
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'avm/instances/base'
+require 'avm/registry/from_gems'
+
+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,40 @@
+# frozen_string_literal: true
+
+require 'avm/registry/with_path'
+
+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,31 @@
+# frozen_string_literal: true
+
+require 'avm/registry/from_gems'
+require 'eac_ruby_utils/core_ext'
+
+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,49 @@
+# frozen_string_literal: true
+
+require 'avm/registry/from_gems'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Registry
+    class WithPath < ::Avm::Registry::FromGems
+      require_sub __FILE__
+
+      # @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(&block)
+        cache.present? ? on_cache_with_cache(&block) : on_cache_with_no_cache(&block)
+      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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/gems_registry'
+
+module Avm
+  module Registry
+    require_sub __FILE__
+    enable_listable
+    lists.add_symbol :category, :applications, :application_scms, :application_stereotypes,
+                     :config_objects, :file_formats, :instances, :launcher_stereotypes, :runners,
+                     :scms, :source_generators, :sources
+
+    class << self
+      enable_simple_cache
+
+      # @return [Array<Avm::Registry::FromGems>]
+      def registries
+        lists.category.values.map { |c| send(c) }
+      end
+
+      private
+
+      ::Avm::Registry.lists.category.each_value do |category|
+        define_method "#{category}_uncached" do
+          registry_class(category).new(category.to_s.camelize)
+        end
+      end
+
+      def registry_class(category)
+        ::Avm::Registry.const_get(category.to_s.camelize)
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/result.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'colorized_string'
+require 'eac_ruby_utils/listable'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  class Result < ::SimpleDelegator
+    include ::EacRubyUtils::Listable
+
+    lists.add_string :type, :success, :error, :neutral, :pending, :outdated
+
+    lists.type.values.each do |type| # rubocop:disable Style/HashEachMethods
+      singleton_class.define_method type do |value|
+        new(value, type)
+      end
+    end
+
+    TYPE_SUCCESS_COLOR = 'green'
+    TYPE_ERROR_COLOR = 'red'
+    TYPE_NEUTRAL_COLOR = 'light_black'
+    TYPE_PENDING_COLOR = 'yellow'
+    TYPE_OUTDATED_COLOR = 'blue'
+
+    class << self
+      # Return Avm::Result.success(success_value) if +success+ is truthy.
+      # Return Avm::Result.error(error_value || success_value) if +success+ is falsely.
+      # @return [Avm::Result]
+      def success_or_error(success, success_value, error_value = nil)
+        if success
+          self.success(success_value)
+        else
+          error(error_value.presence || success_value)
+        end
+      end
+    end
+
+    attr_reader :type
+
+    def initialize(value, type)
+      super(value)
+      validate_type(type)
+      @type = type
+    end
+
+    def label
+      label_fg
+    end
+
+    def label_fg
+      ColorizedString.new(to_s).send(type_color)
+    end
+
+    def label_bg
+      ColorizedString.new(to_s).light_white.send("on_#{type_color}")
+    end
+
+    def type_color
+      self.class.const_get("type_#{type}_color".upcase)
+    end
+
+    lists.type.values.each do |type| # rubocop:disable Style/HashEachMethods
+      define_method "#{type}?" do
+        @type == type
+      end
+    end
+
+    private
+
+    def validate_type(type)
+      return if self.class.lists.type.values.include?(type)
+
+      raise "Tipo desconhecido: \"#{type}\" (Válido: #{self.class.lists.type.values.join(', ')})"
+    end
+
+    class Error < StandardError
+      def to_result
+        ::Avm::Result.error(message)
+      end
+    end
+  end
+end