eac_tools 0.86.13 → 0.87.1

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

data/sub/avm/lib/avm/rspec/setup/launcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'avm/launcher/context'
+require 'eac_ruby_utils/core_ext'
+require 'tmpdir'
+
+module Avm
+  module Rspec
+    module Setup
+      module Launcher
+        def temp_launcher_context(settings_file = nil)
+          settings_file ||= temp_file
+          ::Avm::Launcher::Context.current = ::Avm::Launcher::Context.new(
+            projects_root: ::Dir.mktmpdir, settings_file: settings_file, cache_root: ::Dir.mktmpdir
+          )
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/rspec/setup/source_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Rspec
+    module Setup
+      module SourceGenerator
+        DEFAULT_TARGET_BASENAME = 'generated_app'
+
+        # @return [Avm::Sources::Base]
+        def avm_source(stereotype_name, options = {})
+          options = options.dup
+          target_basename ||= options.delete(:target_basename) || DEFAULT_TARGET_BASENAME
+          target_path ||= options.delete(:target_path) || temp_dir.join(target_basename)
+          ::Avm::Registry.source_generators.detect(stereotype_name, target_path, options).perform
+          ::Avm::Registry.sources.detect(target_path)
+        end
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/rspec/setup.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'avm/rspec/setup/source_generator'
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Rspec
+    module Setup
+      require_sub __FILE__
+      EXAMPLES = %w[avm_file_formats_with_fixtures avm_file_format_file_resource_name
+                    avm_source_generated entries_values in_avm_registry not_in_avm_registry].freeze
+
+      def self.extended(obj)
+        obj.setup_examples
+        obj.rspec_config.include(::Avm::Rspec::Setup::Launcher)
+        obj.rspec_config.include(::Avm::Rspec::Setup::SourceGenerator)
+      end
+
+      def setup_examples
+        EXAMPLES.each do |example|
+          require "avm/rspec/shared_examples/#{example}"
+        end
+      end
+
+      # @return [self]
+      def stub_avm_contexts
+        stub_eac_config_node
+        stub_eac_fs_contexts
+        stub_eac_speaker
+
+        self
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/rspec/shared_examples/avm_file_format_file_resource_name.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+RSpec.shared_examples 'avm_file_format_file_resource_name' do |input_expected|
+  describe '#file_resource_name' do
+    input_expected.each do |path, expected_resource_name|
+      context "when path is \"#{path}\"" do
+        let(:instance) { described_class.new }
+
+        it { expect(instance.file_resource_name(path)).to eq(expected_resource_name) }
+      end
+    end
+  end
+end

data/sub/avm/lib/avm/rspec/shared_examples/avm_file_formats_with_fixtures.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/file_formats/search_formatter'
+require 'eac_ruby_utils/core_ext'
+
+RSpec.shared_examples 'avm_file_formats_with_fixtures' do |the_spec_file|
+  include_examples 'source_target_fixtures', the_spec_file
+
+  def format_files_in_directory(target_dir)
+    Avm::FileFormats::SearchFormatter
+      .new([target_dir], recursive: true, apply: true, verbose: false)
+      .run
+  end
+
+  def source_data(source_file)
+    dir = temp_dir
+    source_basename = source_file_basename_without_source_extname(source_file)
+    source_path = dir.join(source_basename)
+    FileUtils.cp(source_file, source_path)
+    format_files_in_directory(dir)
+    source_path.read
+  end
+
+  def source_file_basename_without_source_extname(source_file)
+    source_file.to_pathname.basename_sub { |b| b.to_path.gsub('.source', '') }.basename
+  end
+
+  def target_data(target_file)
+    File.read(target_file)
+  end
+end