servactory 3.0.2 → 3.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a0bc2bbb7debf437c329c7d5e344e78783002e53a92a8a0375039c1856d2bec
-  data.tar.gz: a313727f841e0e15883684630f6adfe406b7da5f86a653ea031982583698fcad
+  metadata.gz: 1c4398d2ffb193d4acd86b96f02871198d13d4e8b31ec96dddaa05c3966f1525
+  data.tar.gz: bf35a15c0d771ef1c6362d573e2fbd5a04a0021cb0a80d847f37b23d5dff3b76
 SHA512:
-  metadata.gz: df636f9537601f9b60997574b2174e22244e2c5f0600ae79751ec4b0f47b3fb0663f7b9bc619a705df63da45c56df17dea90cd1a835148d74f5bc56597f8692e
-  data.tar.gz: 1e487d7be9f2d86560c75c859e3f9de56a8cab8511f564876fc1002a33141a689f81df242db203f9070f23ee37a8e6290648e46e6ca4e485c22d2941ead51a4a
+  metadata.gz: baa8f5c12c6edbf0786d807611a759f8fd54b3f087967ea981942843e3a19b2f1026f607bc52ad9c5f4dd42830216582e4e54d38bef5e00fa48dea47bbe84210
+  data.tar.gz: c8af2b260386c4c2711a6b034bb116ad843cfb57c5e2b3181d59e9b9d38692ec562afc69bd5b33b46820c20972c0904e9921dfd1516e1576ec8622439ae1b382

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

@@ -29,42 +29,55 @@ module Servactory
           @arguments.keys
         end
 
-        # Merges new arguments into storage.
+        # Merges new arguments into storage and defines accessor methods.
         #
         # @param arguments [Hash] Input name-value pairs to merge
-        # @return [Hash] Updated arguments hash
+        # @return [void]
         def merge!(arguments)
           @arguments.merge!(arguments)
+          define_methods_for!(arguments)
         end
 
-        # Delegates method calls to stored inputs.
+        # Raises error for any method call not pre-defined as a singleton accessor.
         #
         # Supports predicate methods when enabled in config.
         #
         # @param name [Symbol] Method name (input or predicate)
         # @param _args [Array] Method arguments (unused)
-        # @return [Object] Input value or predicate result
+        # @raise [Exception] Failure exception for undefined input
         def method_missing(name, *_args)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
-
           input_name = predicate ? name.to_s.chomp("?").to_sym : name
-
-          input_value = @arguments.fetch(input_name) { raise_error_for(input_name) }
-
-          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
+          raise_error_for(input_name)
         end
 
-        # Checks if method corresponds to stored input.
+        # Returns false since all valid methods are defined as singleton methods.
         #
-        # @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) }
+        # @return [Boolean] Always false
+        def respond_to_missing?(*)
+          false
         end
 
         private
 
+        # Defines singleton accessor methods for given arguments.
+        #
+        # @param arguments [Hash] Input name-value pairs to define methods for
+        # @return [void]
+        def define_methods_for!(arguments)
+          arguments.each_key do |name|
+            define_singleton_method(name) do
+              @arguments.fetch(name) { raise_error_for(name) }
+            end
+
+            next unless @context.config.predicate_methods_enabled
+
+            define_singleton_method(:"#{name}?") do
+              Servactory::Utils.query_attribute(@arguments.fetch(name) { raise_error_for(name) })
+            end
+          end
+        end
+
         # Raises error for undefined input.
         #
         # @param input_name [Symbol] Name of undefined input

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

@@ -7,6 +7,8 @@ module Servactory
         def initialize(context:, collection_of_inputs:)
           @context = context
           @collection_of_inputs = collection_of_inputs
+
+          define_attribute_methods!
         end
 
         def only(*names)
@@ -24,41 +26,48 @@ module Servactory
         def method_missing(name, *_args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-
             raise_error_for(:assign, prepared_name)
           else
-            fetch_with(name:) { raise_error_for(:fetch, name) }
+            raise_error_for(:fetch, name)
           end
         end
 
-        def respond_to_missing?(name, *)
-          @collection_of_inputs.names.include?(name) || super
+        def respond_to_missing?(*)
+          false
         end
 
         private
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
-        def fetch_with(name:, &block)
-          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+        def define_attribute_methods!
+          @collection_of_inputs.each do |input|
+            define_singleton_method(input.internal_name) do
+              fetch_value(attribute: input)
+            end
 
-          input_name = predicate ? name.to_s.chomp("?").to_sym : name
+            next unless @context.config.predicate_methods_enabled
 
-          input = @collection_of_inputs.find_by(name: input_name)
-
-          return yield if input.nil?
+            define_singleton_method(:"#{input.internal_name}?") do
+              fetch_predicate(attribute: input)
+            end
+          end
+        end
 
-          input_value = @context.send(:servactory_service_warehouse).fetch_input(input.name)
+        def fetch_value(attribute:)
+          value = @context.send(:servactory_service_warehouse).fetch_input(attribute.name)
 
-          if input.optional? && !input.default.nil? && !Servactory::Utils.value_present?(input_value)
-            input_value = input.default
+          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
 
-          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
+        def fetch_predicate(attribute:)
+          Servactory::Utils.query_attribute(fetch_value(attribute:))
         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

@@ -7,6 +7,9 @@ module Servactory
         def initialize(context:, collection_of_internals:)
           @context = context
           @collection_of_internals = collection_of_internals
+          @validated_attributes = Set.new
+
+          define_attribute_methods!
         end
 
         def only(*names)
@@ -21,55 +24,69 @@ module Servactory
             .to_h { |internal| [internal.name, send(internal.name)] }
         end
 
-        def method_missing(name, *args)
+        def method_missing(name, *_args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-
-            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
+            raise_error_for(:assign, prepared_name)
           else
-            fetch_with(name:) { raise_error_for(:fetch, name) }
+            raise_error_for(:fetch, name)
           end
         end
 
-        def respond_to_missing?(name, *)
-          @collection_of_internals.names.include?(name) || super
+        def respond_to_missing?(*)
+          false
         end
 
         private
 
-        def assign_with(prepared_name:, value:, &block) # rubocop:disable Lint/UnusedMethodArgument
-          return yield unless @collection_of_internals.names.include?(prepared_name)
+        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
+          @collection_of_internals.each do |internal|
+            define_singleton_method(internal.name) do
+              fetch_value(attribute: internal)
+            end
 
-          internal = @collection_of_internals.find_by(name: prepared_name) # ::Servactory::Internals::Internal
+            define_singleton_method(:"#{internal.name}=") do |value|
+              assign_value(attribute: internal, value:)
+            end
 
-          return yield if internal.nil?
+            next unless @context.config.predicate_methods_enabled
 
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
+            define_singleton_method(:"#{internal.name}?") do
+              fetch_predicate(attribute: internal)
+            end
+          end
+        end
+
+        def assign_value(attribute:, value:)
+          @validated_attributes.delete(attribute.name)
+
+          Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute: internal,
+            attribute:,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
-        end
+          @context.send(:servactory_service_warehouse).assign_internal(attribute.name, value)
 
-        def fetch_with(name:, &block) # rubocop:disable Metrics/MethodLength, Lint/UnusedMethodArgument
-          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
-
-          internal_name = predicate ? name.to_s.chomp("?").to_sym : name
-          internal = @collection_of_internals.find_by(name: internal_name)
+          @validated_attributes << attribute.name
+        end
 
-          return yield if internal.nil?
+        def fetch_value(attribute:)
+          value = @context.send(:servactory_service_warehouse).fetch_internal(attribute.name)
 
-          internal_value = @context.send(:servactory_service_warehouse).fetch_internal(internal.name)
+          if @validated_attributes.exclude?(attribute.name)
+            Servactory::Maintenance::Validations::Performer.validate!(
+              context: @context,
+              attribute:,
+              value:
+            )
+          end
 
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
-            context: @context,
-            attribute: internal,
-            value: internal_value
-          )
+          value
+        end
 
-          predicate ? Servactory::Utils.query_attribute(internal_value) : internal_value
+        def fetch_predicate(attribute:)
+          Servactory::Utils.query_attribute(fetch_value(attribute:))
         end
 
         def raise_error_for(type, name)

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

@@ -7,6 +7,8 @@ module Servactory
         def initialize(context:, collection_of_outputs:)
           @context = context
           @collection_of_outputs = collection_of_outputs
+
+          define_attribute_methods!
         end
 
         def only(*names)
@@ -21,49 +23,55 @@ module Servactory
             .to_h { |output| [output.name, send(output.name)] }
         end
 
-        def method_missing(name, *args)
+        def method_missing(name, *_args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-
-            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
+            raise_error_for(:assign, prepared_name)
           else
-            fetch_with(name:) { raise_error_for(:fetch, name) }
+            raise_error_for(:fetch, name)
           end
         end
 
-        def respond_to_missing?(name, *)
-          @collection_of_outputs.names.include?(name) || super
+        def respond_to_missing?(*)
+          false
         end
 
         private
 
-        def assign_with(prepared_name:, value:, &block) # rubocop:disable Lint/UnusedMethodArgument
-          return yield unless @collection_of_outputs.names.include?(prepared_name)
+        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
+          @collection_of_outputs.each do |output|
+            define_singleton_method(output.name) do
+              fetch_value(attribute: output)
+            end
+
+            define_singleton_method(:"#{output.name}=") do |value|
+              assign_value(attribute: output, value:)
+            end
 
-          output = @collection_of_outputs.find_by(name: prepared_name)
+            next unless @context.config.predicate_methods_enabled
 
-          return yield if output.nil?
+            define_singleton_method(:"#{output.name}?") do
+              fetch_predicate(attribute: output)
+            end
+          end
+        end
 
-          Servactory::Maintenance::Attributes::Tools::Validation.validate!(
+        def assign_value(attribute:, value:)
+          Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute: output,
+            attribute:,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_output(output.name, value)
+          @context.send(:servactory_service_warehouse).assign_output(attribute.name, value)
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Lint/UnusedMethodArgument
-          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
-
-          output_name = predicate ? name.to_s.chomp("?").to_sym : name
-          output = @collection_of_outputs.find_by(name: output_name)
-
-          return yield if output.nil?
-
-          output_value = @context.send(:servactory_service_warehouse).fetch_output(output.name)
+        def fetch_value(attribute:)
+          @context.send(:servactory_service_warehouse).fetch_output(attribute.name)
+        end
 
-          predicate ? Servactory::Utils.query_attribute(output_value) : output_value
+        def fetch_predicate(attribute:)
+          Servactory::Utils.query_attribute(fetch_value(attribute:))
         end
 
         def raise_error_for(type, name)

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