servactory 3.0.0 → 3.1.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b84875a142c1878a68ea71f3874019a8028bc8eff3836706d3079107b06761b
-  data.tar.gz: 2a47fd738513716831e2fd491266e1c122a1200bcff9737d90a47087e95f2f64
+  metadata.gz: 6a7c9b4d9ad2e7d15265ba278d740eb34e6df33590bf517a0b42d914dad46e22
+  data.tar.gz: 21ad5c1814f6bd2c62221057547f5388cf928fd1f937f37131dab041d6325983
 SHA512:
-  metadata.gz: 502fdff740f4a46378ee1b8664279fbc2cebfb7fe4fa01025a30499d3504ae1ae84b1ead432e28b1e23d59a572ba685690c88e681633bcb02020df5756e6328d
-  data.tar.gz: 14482adc188d556373eaa482502f2bd59533ca5a8e3d6b590109cb6cf18755c9ae34a77df79baa7d654fd0657b7202821d2983447c8485525b62445bd4ac7898
+  metadata.gz: 9f231bf3c0662ec8285125cacd138d765622eb1ebad7e9eae5d95ae2dd84ad48f80a65783e208b3b9752e40e9bc755ca245bcf2f3b1c68b3724ca13a68d1f6a5
+  data.tar.gz: 8fb3f9f3bcf2a49f26d4cff76885537559ba4173c78585c2432fc7bf814a8e587303dc941c36a7992800bff1c561661cc04ae20beffbc17dac4d5a0af64de387

data/lib/servactory/actions/action.rb

@@ -13,11 +13,11 @@ module Servactory
         @position = position
 
         @is_condition_opposite = false
-        @condition = options.fetch(:if, nil)
+        @condition = options[:if]
 
         return unless @condition.nil?
 
-        @condition = options.fetch(:unless, nil)
+        @condition = options[:unless]
 
         @is_condition_opposite = true unless @condition.nil?
       end

data/lib/servactory/actions/collection.rb

@@ -67,7 +67,7 @@ module Servactory
       #   sorted = actions.sorted_by_position
       #   sorted.each { |action| puts action.position }
       def sorted_by_position
-        Collection.new(sort_by(&:position))
+        @sorted_by_position ||= Collection.new(sort_by(&:position))
       end
     end
   end

data/lib/servactory/actions/stages/collection.rb

@@ -13,7 +13,7 @@ module Servactory
         end
 
         def sorted_by_position
-          Collection.new(sort_by(&:position))
+          @sorted_by_position ||= Collection.new(sort_by(&:position))
         end
       end
     end

data/lib/servactory/configuration/option_helpers/option_helpers_collection.rb

@@ -3,26 +3,84 @@
 module Servactory
   module Configuration
     module OptionHelpers
+      # Collection wrapper for managing option helper objects.
+      #
+      # ## Purpose
+      #
+      # OptionHelpersCollection provides a unified interface for storing and
+      # querying Helper instances used by the configuration system.
+      # It wraps a Set to ensure uniqueness and delegates common enumeration methods.
+      #
+      # ## Usage
+      #
+      # The collection is used internally by the configuration system
+      # to manage registered option helpers:
+      #
+      # ```ruby
+      # collection = OptionHelpersCollection.new
+      # collection << helper
+      #
+      # collection.find_by(name: :must)   # => helper instance
+      # collection.dynamic_options        # => filtered OptionHelpersCollection
+      # ```
+      #
+      # ## Performance
+      #
+      # The collection uses memoization for frequently accessed data:
+      # - `helpers_index` - cached hash for O(1) lookups by name
+      #
       class OptionHelpersCollection
         extend Forwardable
 
-        def_delegators :@collection, :<<, :filter, :map, :find, :merge
+        def_delegators :@collection,
+                       :<<,
+                       :filter,
+                       :each_with_object,
+                       :map,
+                       :merge
 
+        # Initializes the collection with an optional pre-built Set.
+        #
+        # @param collection [Set] initial set of helpers
+        # @return [OptionHelpersCollection]
         def initialize(collection = Set.new)
           @collection = collection
         end
 
+        # Duplicates the collection, resetting memoized caches.
+        #
+        # @param original [OptionHelpersCollection] the collection being duplicated
+        # @return [void]
         def initialize_dup(original)
           super
           @collection = original.instance_variable_get(:@collection).dup
+          @helpers_index = nil
         end
 
+        # Returns a new collection containing only dynamic option helpers.
+        #
+        # @return [OptionHelpersCollection] filtered collection of dynamic helpers
         def dynamic_options
           OptionHelpersCollection.new(filter(&:dynamic_option?))
         end
 
+        # Finds a helper by its name using indexed lookup.
+        #
+        # @param name [Symbol] the helper name to find
+        # @return [Maintenance::Options::Helper, nil] the found helper or nil
         def find_by(name:)
-          find { |helper| helper.name == name }
+          helpers_index[name]
+        end
+
+        private
+
+        # Builds and caches a hash index for O(1) helper lookups.
+        #
+        # @return [Hash{Symbol => Maintenance::Options::Helper}] helper names mapped to Helper instances
+        def helpers_index
+          @helpers_index ||= each_with_object({}) do |helper, index|
+            index[helper.name] = helper
+          end
         end
       end
     end

data/lib/servactory/context/warehouse/inputs.rb

@@ -57,10 +57,10 @@ module Servactory
         # Checks if method corresponds to stored input.
         #
         # @param name [Symbol] Method name to check
-        # @param _include_private [Boolean] Include private methods in check
         # @return [Boolean] True if input exists for this method
         def respond_to_missing?(name, *)
-          @arguments.fetch(name) { raise_error_for(name) }
+          input_name = name.to_s.chomp("?").to_sym
+          @arguments.key?(input_name) || @arguments.key?(name) || super
         end
 
         private

data/lib/servactory/context/workspace/inputs.rb

@@ -32,13 +32,12 @@ module Servactory
         end
 
         def respond_to_missing?(name, *)
-          @collection_of_inputs.names.include?(name) || super
+          resolve_input(name) || super
         end
 
         private
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
-        def fetch_with(name:, &block)
+        def fetch_with(name:, &_block)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
 
           input_name = predicate ? name.to_s.chomp("?").to_sym : name
@@ -47,18 +46,31 @@ module Servactory
 
           return yield if input.nil?
 
-          input_value = @context.send(:servactory_service_warehouse).fetch_input(input.name)
+          value = fetch_value(attribute: input)
 
-          if input.optional? && !input.default.nil? && !Servactory::Utils.value_present?(input_value)
-            input_value = input.default
+          predicate ? Servactory::Utils.query_attribute(value) : value
+        end
+
+        def fetch_value(attribute:)
+          value = @context.send(:servactory_service_warehouse).fetch_input(attribute.name)
+
+          if attribute.optional? && !attribute.default.nil? && !Servactory::Utils.value_present?(value)
+            value = attribute.default
           end
 
-          input_prepare = input.prepare[:in]
-          input_value = input_prepare.call(value: input_value) if input_prepare
+          prepare = attribute.prepare[:in]
+          value = prepare.call(value:) if prepare
+
+          value
+        end
+
+        def resolve_input(name)
+          return true if @collection_of_inputs.find_by(name:)
 
-          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_inputs.find_by(name: name.to_s.chomp("?").to_sym)
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
 
         def raise_error_for(type, name)
           message_text = @context.send(:servactory_service_info).translate(

data/lib/servactory/context/workspace/internals.rb

@@ -32,28 +32,34 @@ module Servactory
         end
 
         def respond_to_missing?(name, *)
-          @collection_of_internals.names.include?(name) || super
+          resolve_internal(name) || super
         end
 
         private
 
-        def assign_with(prepared_name:, value:, &block) # rubocop:disable Lint/UnusedMethodArgument
-          return yield unless @collection_of_internals.names.include?(prepared_name)
+        def validated_attributes
+          @validated_attributes ||= Set.new
+        end
 
-          internal = @collection_of_internals.find_by(name: prepared_name) # ::Servactory::Internals::Internal
+        def assign_with(prepared_name:, value:, &_block)
+          internal = @collection_of_internals.find_by(name: prepared_name)
 
           return yield if internal.nil?
 
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
+          validated_attributes.delete(internal.name)
+
+          Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
             attribute: internal,
             value:
           )
 
           @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
+
+          validated_attributes << internal.name
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Metrics/MethodLength, Lint/UnusedMethodArgument
+        def fetch_with(name:, &_block)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
 
           internal_name = predicate ? name.to_s.chomp("?").to_sym : name
@@ -61,17 +67,33 @@ module Servactory
 
           return yield if internal.nil?
 
-          internal_value = @context.send(:servactory_service_warehouse).fetch_internal(internal.name)
-
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
-            context: @context,
-            attribute: internal,
-            value: internal_value
-          )
+          internal_value = fetch_value(attribute: internal)
 
           predicate ? Servactory::Utils.query_attribute(internal_value) : internal_value
         end
 
+        def fetch_value(attribute:)
+          value = @context.send(:servactory_service_warehouse).fetch_internal(attribute.name)
+
+          if validated_attributes.exclude?(attribute.name)
+            Servactory::Maintenance::Validations::Performer.validate!(
+              context: @context,
+              attribute:,
+              value:
+            )
+          end
+
+          value
+        end
+
+        def resolve_internal(name)
+          return true if @collection_of_internals.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_internals.find_by(name: name.to_s.chomp("?").to_sym)
+        end
+
         def raise_error_for(type, name)
           message_text = @context.send(:servactory_service_info).translate(
             "internals.undefined.for_#{type}",

data/lib/servactory/context/workspace/outputs.rb

@@ -32,19 +32,17 @@ module Servactory
         end
 
         def respond_to_missing?(name, *)
-          @collection_of_outputs.names.include?(name) || super
+          resolve_output(name) || super
         end
 
         private
 
-        def assign_with(prepared_name:, value:, &block) # rubocop:disable Lint/UnusedMethodArgument
-          return yield unless @collection_of_outputs.names.include?(prepared_name)
-
+        def assign_with(prepared_name:, value:, &_block)
           output = @collection_of_outputs.find_by(name: prepared_name)
 
           return yield if output.nil?
 
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
+          Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
             attribute: output,
             value:
@@ -53,7 +51,7 @@ module Servactory
           @context.send(:servactory_service_warehouse).assign_output(output.name, value)
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Lint/UnusedMethodArgument
+        def fetch_with(name:, &_block)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
 
           output_name = predicate ? name.to_s.chomp("?").to_sym : name
@@ -66,6 +64,14 @@ module Servactory
           predicate ? Servactory::Utils.query_attribute(output_value) : output_value
         end
 
+        def resolve_output(name)
+          return true if @collection_of_outputs.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_outputs.find_by(name: name.to_s.chomp("?").to_sym)
+        end
+
         def raise_error_for(type, name)
           message_text = @context.send(:servactory_service_info).translate(
             "outputs.undefined.for_#{type}",

data/lib/servactory/dsl.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module DSL
-    STROMA = Stroma::Matrix.define(:my_lib) do
+    STROMA = Stroma::Matrix.define(:servactory) do
       register(:configuration, Configuration::DSL)
       register(:info, Info::DSL)
       register(:context, Context::DSL)

data/lib/servactory/info/builder.rb

@@ -138,15 +138,14 @@ module Servactory
       end
 
       def extract_message_from_value(value:)
-        value.is_a?(Hash) ? value.fetch(:message, nil) : nil
+        value.is_a?(Hash) ? value[:message] : nil
       end
 
       def enrich_options_with_common_fields(attribute:, options:)
-        actor = attribute.class::Actor.new(attribute)
         must = attribute.collection_of_options.find_by(name: :must)
 
         options.merge(
-          actor:,
+          actor: attribute.actor,
           types: attribute.types,
           must: must&.value
         )

data/lib/servactory/inputs/collection.rb

@@ -2,29 +2,22 @@
 
 module Servactory
   module Inputs
-    class Collection
-      extend Forwardable
+    # Specialized collection for Input attributes.
+    #
+    # Overrides `lookup_name` to use `internal_name` instead of `name`,
+    # supporting the `as:` parameter that renames inputs internally.
+    # Adds `flat_map` delegation for input-specific enumeration needs.
+    class Collection < Servactory::Maintenance::Attributes::Collection
+      def_delegators :@collection, :flat_map
 
-      def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :to_h, :merge, :find
+      private
 
-      def initialize(collection = Set.new)
-        @collection = collection
-      end
-
-      def only(*names)
-        Collection.new(filter { |input| names.include?(input.internal_name) })
-      end
-
-      def except(*names)
-        Collection.new(filter { |input| names.exclude?(input.internal_name) })
-      end
-
-      def names
-        map(&:name)
-      end
-
-      def find_by(name:)
-        find { |input| input.internal_name == name }
+      # Returns `internal_name` for indexing, supporting the `as:` parameter.
+      #
+      # @param attribute [Object] the input attribute
+      # @return [Symbol] the internal name used for lookup
+      def lookup_name(attribute)
+        attribute.internal_name
       end
     end
   end

data/lib/servactory/inputs/input.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Inputs
-    class Input # rubocop:disable Metrics/ClassLength
+    class Input < Servactory::Maintenance::Attributes::Base
       class Actor
         attr_reader :name,
                     :internal_name,
@@ -38,22 +38,19 @@ module Servactory
         # The methods below are required to support the internal work.
 
         def input?
-          true
+          @attribute.input?
         end
 
         def internal?
-          false
+          @attribute.internal?
         end
 
         def output?
-          false
+          @attribute.output?
         end
       end
 
-      attr_reader :name,
-                  :internal_name,
-                  :collection_of_options,
-                  :options
+      attr_reader :internal_name
 
       # rubocop:disable Style/KeywordParametersOrder
       def initialize(
@@ -63,49 +60,16 @@ module Servactory
         option_helpers:,
         **options
       )
-        @name = name
         @internal_name = as.presence || name
-        @option_helpers = option_helpers
 
-        register_options(helpers:, options:)
+        super(name, *helpers, option_helpers:, **options)
       end
       # rubocop:enable Style/KeywordParametersOrder
 
-      def method_missing(name, *args, &block)
-        option = @collection_of_options.find_by(name:)
-        return super if option.nil?
-
-        option.body
-      end
-
-      def respond_to_missing?(name, *)
-        @collection_of_options.names.include?(name) || super
-      end
-
-      def register_options(helpers:, options:)
-        merged_options = augment_options_with_helpers(helpers:, options:)
-        options_registrar = create_options_registrar(options: merged_options)
-
-        @options = merged_options
-        @collection_of_options = options_registrar.collection
-      end
-
-      def options_for_checks
-        @collection_of_options.options_for_checks
-      end
-
       def conflict_code
         @collection_of_options.defined_conflict_code
       end
 
-      def system_name
-        self.class.name.demodulize.downcase.to_sym
-      end
-
-      def i18n_name
-        system_name.to_s.pluralize
-      end
-
       def with_conflicts?
         conflict_code.present?
       end
@@ -114,24 +78,8 @@ module Servactory
         true
       end
 
-      def internal?
-        false
-      end
-
-      def output?
-        false
-      end
-
       private
 
-      def create_options_registrar(options:)
-        Servactory::Maintenance::Attributes::Options::Registrar.register(
-          attribute: self,
-          options:,
-          features: available_feature_options
-        )
-      end
-
       def available_feature_options
         {
           required: true,
@@ -141,51 +89,6 @@ module Servactory
           prepare: true
         }
       end
-
-      def augment_options_with_helpers(helpers:, options:)
-        result_options = options.dup
-        merge_standard_helpers_into(target_options: result_options, helpers:) if helpers.present?
-        merge_advanced_helpers_into(target_options: result_options, source_options: options)
-        result_options
-      end
-
-      def merge_standard_helpers_into(target_options:, helpers:)
-        standard_helpers_result = transform_helpers_to_options(helpers:)
-        target_options.deep_merge!(standard_helpers_result)
-      end
-
-      def merge_advanced_helpers_into(target_options:, source_options:)
-        advanced_helpers = filter_advanced_helpers(options: source_options)
-        return if advanced_helpers.blank?
-
-        advanced_helpers_result = transform_helpers_to_options(helpers: advanced_helpers)
-        target_options.deep_merge!(advanced_helpers_result)
-      end
-
-      def filter_advanced_helpers(options:)
-        reserved_options = Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS
-        options.except(*reserved_options)
-      end
-
-      def transform_helpers_to_options(helpers:)
-        helpers.each_with_object({}) do |(helper_name, values), result|
-          helper = @option_helpers.find_by(name: helper_name)
-          next if helper.blank?
-
-          transformed_option = transform_helper_to_option(helper:, values:)
-          result.deep_merge!(transformed_option) if transformed_option.present?
-        end
-      end
-
-      def transform_helper_to_option(helper:, values:)
-        return helper.equivalent unless helper.equivalent.is_a?(Proc)
-
-        if values.is_a?(Hash)
-          helper.equivalent.call(**values)
-        else
-          helper.equivalent.call(values)
-        end
-      end
     end
   end
 end