servactory 3.0.4 → 3.1.0.rc1

data/lib/servactory/maintenance/{attributes/validations → validations/checkers}/type.rb

@@ -2,8 +2,8 @@
 
 module Servactory
   module Maintenance
-    module Attributes
-      module Validations
+    module Validations
+      module Checkers
         # Validates that attribute values match their declared types.
         #
         # ## Purpose
@@ -35,13 +35,14 @@ module Servactory
           # @param attribute [Inputs::Input, Internals::Internal, Outputs::Output] Attribute to validate
           # @param value [Object] Value to check against declared types
           # @param check_key [Symbol] Must be :types to trigger validation
+          # @param check_options [Hash, nil] Unused, accepted for uniform checker interface
           # @return [String, nil] Error message on type mismatch, nil on success
-          def self.check(context:, attribute:, value:, check_key:, **)
+          def self.check(context:, attribute:, value:, check_key:, check_options: nil) # rubocop:disable Lint/UnusedMethodArgument
             return unless should_be_checked_for?(attribute, value, check_key)
 
             prepared_value = compute_prepared_value(attribute, value)
 
-            error_data = Servactory::Maintenance::Validations::Types.validate(
+            error_data = Servactory::Maintenance::Validations::Support::TypeValidator.validate(
               context:,
               attribute:,
               types: attribute.types,
@@ -99,7 +100,7 @@ module Servactory
 
           # Builds error message from validation error data.
           #
-          # @param error_data [Hash] Error data from Types.validate
+          # @param error_data [Hash] Error data from TypeValidator.validate
           # @return [String] Processed error message
           def self.build_error_message(error_data)
             process_message(error_data[:message], **error_data)

data/lib/servactory/maintenance/validations/concerns/error_builder.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      module Concerns
+        # Concern providing error message processing for validators.
+        #
+        # ## Purpose
+        #
+        # ErrorBuilder provides shared logic for processing error messages that
+        # can be either static strings or dynamic Procs. This allows validators
+        # to support both simple error messages and context-aware messages.
+        #
+        # ## Usage
+        #
+        # Extend in validator classes:
+        #
+        # ```ruby
+        # class MyValidator
+        #   extend Concerns::ErrorBuilder
+        #
+        #   def self.build_error(...)
+        #     process_message(message, **context)
+        #   end
+        # end
+        # ```
+        #
+        # ## Methods Provided
+        #
+        # - `process_message` - converts String or Proc message to String
+        module ErrorBuilder
+          # Processes a message that may be a String or Proc.
+          #
+          # If message is a Proc, calls it with the provided attributes.
+          # If message is a String, returns it unchanged.
+          #
+          # @param message [String, Proc] The message to process
+          # @param attributes [Hash] Attributes to pass to Proc if message is callable
+          # @return [String] The processed message string
+          def process_message(message, **attributes)
+            return message unless message.is_a?(Proc)
+
+            message.call(**attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/validations/performer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      module Performer
+        extend self
+
+        def validate!(context:, attribute:, value:)
+          first_error = process(context:, attribute:, value:)
+          return if first_error.nil?
+
+          context.public_send(
+            :"fail_#{attribute.system_name}!",
+            attribute.name,
+            message: first_error
+          )
+        end
+
+        private
+
+        def process(context:, attribute:, value:) # rubocop:disable Metrics/MethodLength
+          attribute.options_for_checks.each do |check_key, check_options|
+            error = process_option(
+              context:,
+              attribute:,
+              value:,
+              check_key:,
+              check_options:
+            )
+            return error if error.present?
+          end
+
+          nil
+        end
+
+        def process_option(context:, attribute:, value:, check_key:, check_options:) # rubocop:disable Metrics/MethodLength
+          validation_classes = attribute.collection_of_options.validation_classes
+          return if validation_classes.empty?
+
+          validation_classes.each do |validation_class|
+            error_message = validation_class.check(
+              context:,
+              attribute:,
+              value:,
+              check_key:,
+              check_options:
+            )
+            return error_message if error_message.present?
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/validations/support/type_validator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      module Support
+        class TypeValidator
+          # Validates value against expected types.
+          #
+          # Returns nil on success, error data Hash on failure.
+          #
+          # @param context [Object] Service context for error info
+          # @param attribute [Inputs::Input, Internals::Internal, Outputs::Output] Attribute being validated
+          # @param types [Array<Class, String, Symbol>] Expected type classes
+          # @param value [Object] Value to validate
+          # @return [Hash, nil] nil on success, error data Hash on failure
+          def self.validate(context:, attribute:, types:, value:) # rubocop:disable Metrics/MethodLength
+            prepared_types = types.map { |type| Servactory::Utils.constantize_class(type) }
+
+            return if prepared_types.any? { |type| value.is_a?(type) }
+
+            {
+              message: Servactory::Maintenance::Validations::Translator::Type.default_message,
+              service: context.send(:servactory_service_info),
+              attribute:,
+              value:,
+              key_name: nil,
+              expected_type: prepared_types.join(", "),
+              given_type: value.class.name
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/{attributes → validations}/translator/must.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Maintenance
-    module Attributes
+    module Validations
       module Translator
         module Must
           module_function

data/lib/servactory/maintenance/{attributes → validations}/translator/type.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Maintenance
-    module Attributes
+    module Validations
       module Translator
         module Type
           module_function

data/lib/servactory/outputs/collection.rb

@@ -2,30 +2,11 @@
 
 module Servactory
   module Outputs
-    class Collection
-      extend Forwardable
-
-      def_delegators :@collection, :<<, :filter, :each, :map, :to_h, :merge, :find
-
-      def initialize(collection = Set.new)
-        @collection = collection
-      end
-
-      def only(*names)
-        Collection.new(filter { |internal| names.include?(internal.name) })
-      end
-
-      def except(*names)
-        Collection.new(filter { |internal| names.exclude?(internal.name) })
-      end
-
-      def names
-        map(&:name)
-      end
-
-      def find_by(name:)
-        find { |output| output.name == name }
-      end
+    # Specialized collection for Output attributes.
+    #
+    # Inherits all behavior from the base Attributes::Collection
+    # without any overrides.
+    class Collection < Servactory::Maintenance::Attributes::Collection
     end
   end
 end

data/lib/servactory/outputs/output.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Outputs
-    class Output
+    class Output < Servactory::Maintenance::Attributes::Base
       class Actor
         attr_reader :name,
                     :types,
@@ -26,138 +26,30 @@ module Servactory
         # The methods below are required to support the internal work.
 
         def input?
-          false
+          @attribute.input?
         end
 
         def internal?
-          false
+          @attribute.internal?
         end
 
         def output?
-          true
+          @attribute.output?
         end
       end
 
-      attr_reader :name,
-                  :collection_of_options,
-                  :options
-
-      def initialize(
-        name,
-        *helpers,
-        option_helpers:,
-        **options
-      )
-        @name = name
-        @option_helpers = option_helpers
-
-        register_options(helpers:, options:)
-      end
-
-      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 system_name
-        self.class.name.demodulize.downcase.to_sym
-      end
-
-      def i18n_name
-        system_name.to_s.pluralize
-      end
-
-      def input?
-        false
-      end
-
-      def internal?
-        false
-      end
-
       def output?
         true
       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
         {
           types: true,
           must: 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

data/lib/servactory/result.rb

@@ -41,10 +41,10 @@ module Servactory
   # ```ruby
   # result.active?  # Equivalent to Utils.query_attribute(result.active)
   # ```
-  class Result
+  class Result # rubocop:disable Metrics/ClassLength
     # Internal container for service output values.
     #
-    # Provides dynamic method access to output values via method_missing.
+    # Provides dynamic method access to output values.
     # Stores outputs in hash and supports predicate methods when enabled.
     class Outputs
       # Creates an Outputs container with given output values.
@@ -55,6 +55,8 @@ module Servactory
       def initialize(outputs:, predicate_methods_enabled:)
         @outputs = outputs
         @predicate_methods_enabled = predicate_methods_enabled
+
+        define_attribute_methods!
       end
 
       # Returns string representation for debugging.
@@ -64,45 +66,26 @@ module Servactory
         "#<#{self.class.name} #{draw_result}>"
       end
 
-      # Delegates method calls to stored outputs.
+      private
+
+      # Defines singleton accessor methods for output values on this instance.
       #
-      # Supports both regular output access and predicate methods
-      # when predicate_methods_enabled is true.
+      # Creates getter methods for each output key and, when predicate methods
+      # are enabled, predicate methods (e.g., user?) for boolean queries.
       #
-      # @param name [Symbol] Method name (output or predicate)
-      # @param args [Array] Method arguments
-      # @return [Object] Output value or predicate result
-      def method_missing(name, *args)
-        if name.to_s.end_with?("?")
-          base_name = name.to_s.chomp("?").to_sym
-          if @predicate_methods_enabled && @outputs.key?(base_name)
-            return Servactory::Utils.query_attribute(@outputs[base_name])
-          end
-        elsif @outputs.key?(name)
-          return @outputs[name]
-        end
+      # @return [void]
+      def define_attribute_methods!
+        @outputs.each_key do |name|
+          define_singleton_method(name) { @outputs[name] }
 
-        super
-      end
+          next unless @predicate_methods_enabled
 
-      # Checks if method corresponds to stored output.
-      #
-      # @param name [Symbol] Method name to check
-      # @param include_private [Boolean] Include private methods in check
-      # @return [Boolean] True if output exists for this method
-      def respond_to_missing?(name, include_private = false)
-        if name.to_s.end_with?("?")
-          base_name = name.to_s.chomp("?").to_sym
-          return true if @predicate_methods_enabled && @outputs.key?(base_name)
-        elsif @outputs.key?(name)
-          return true
+          define_singleton_method(:"#{name}?") do
+            Servactory::Utils.query_attribute(@outputs[name])
+          end
         end
-
-        super
       end
 
-      private
-
       # Returns array of output attribute names.
       #
       # @return [Array<Symbol>] Output names without predicates
@@ -297,15 +280,16 @@ module Servactory
       self
     end
 
-    # Delegates method calls to outputs container.
+    # Delegates method calls to the outputs container.
     #
-    # Provides access to output attributes as if they were
-    # defined on the Result instance itself.
+    # On first access, triggers lazy initialization of outputs and
+    # installs singleton delegator methods for subsequent direct access.
     #
     # @param name [Symbol] Method name (output attribute)
     # @param args [Array] Method arguments
     # @param block [Proc] Optional block
-    # @return [Object] Output value
+    # @return [Object] Output value when name matches an output attribute
+    # @raise [NoMethodError] When method is truly undefined and no context present
     def method_missing(name, *args, &block)
       return outputs.public_send(name, *args, &block) if outputs.respond_to?(name)
 
@@ -348,9 +332,19 @@ module Servactory
 
     # Returns outputs container, lazily initialized.
     #
+    # On first access, also defines singleton delegator methods on this
+    # Result instance for subsequent direct access.
+    #
     # @return [Outputs] Outputs container with service values
     def outputs
-      @outputs ||= Outputs.new(
+      @outputs ||= build_outputs.tap { |outputs_container| define_output_delegators!(outputs_container) }
+    end
+
+    # Builds Outputs container with predicate configuration.
+    #
+    # @return [Outputs] New outputs container
+    def build_outputs
+      Outputs.new(
         outputs: build_outputs_hash,
         predicate_methods_enabled:
           @context.is_a?(Servactory::TestKit::Result) || @context.config.predicate_methods_enabled
@@ -368,6 +362,21 @@ module Servactory
       hash
     end
 
+    # Defines singleton delegator methods on this Result instance
+    # for direct access to output values without method_missing.
+    #
+    # @param outputs_container [Outputs] Outputs container to delegate to
+    # @return [void]
+    def define_output_delegators!(outputs_container)
+      outputs_container.send(:output_names).each do |name|
+        define_singleton_method(name) { outputs.public_send(name) }
+      end
+
+      outputs_container.send(:predicate_names).each do |name|
+        define_singleton_method(name) { outputs.public_send(name) }
+      end
+    end
+
     ########################################################################
 
     # Wraps NoMethodError with contextual failure.

data/lib/servactory/tool_kit/dynamic_options/consists_of.rb

@@ -88,8 +88,7 @@ module Servactory
         # Creates a ConsistsOf validator instance.
         #
         # @param option_name [Symbol] The option name (default: :consists_of)
-        # @param collection_mode_class_names [Servactory::Configuration::CollectionMode::ClassNamesCollection]
-        #   Valid collection types
+        # @param collection_mode_class_names [Array<Class>] Valid collection types
         # @return [Servactory::Maintenance::Attributes::OptionHelper]
         def self.use(option_name = :consists_of, collection_mode_class_names:)
           instance = new(option_name, :type, false)
@@ -99,8 +98,7 @@ module Servactory
 
         # Assigns the list of valid collection class names.
         #
-        # @param collection_mode_class_names [Servactory::Configuration::CollectionMode::ClassNamesCollection]
-        #   Collection types to accept
+        # @param collection_mode_class_names [Array<Class>] Collection types to accept
         # @return [void]
         def assign(collection_mode_class_names)
           @collection_mode_class_names = collection_mode_class_names

data/lib/servactory/tool_kit/dynamic_options/must.rb

@@ -155,9 +155,9 @@ module Servactory
         # Creates an OptionHelper for registration with Servactory.
         #
         # @param name [Symbol] Internal validation name
-        # @return [Servactory::Maintenance::Attributes::OptionHelper]
+        # @return [Servactory::Maintenance::Options::Helper]
         def must(name)
-          Servactory::Maintenance::Attributes::OptionHelper.new(
+          Servactory::Maintenance::Options::Helper.new(
             name: @option_name,
             equivalent: equivalent_with(name),
             meta: {

data/lib/servactory/tool_kit/dynamic_options/schema.rb

@@ -127,8 +127,7 @@ module Servactory
         # Creates a Schema validator instance.
         #
         # @param option_name [Symbol] The option name (default: :schema)
-        # @param default_hash_mode_class_names [Servactory::Configuration::HashMode::ClassNamesCollection]
-        #   Valid Hash-like types
+        # @param default_hash_mode_class_names [Array<Class>] Valid Hash-like types
         # @return [Servactory::Maintenance::Attributes::OptionHelper]
         def self.use(option_name = :schema, default_hash_mode_class_names:)
           instance = new(option_name, :is, false)
@@ -138,8 +137,7 @@ module Servactory
 
         # Assigns the list of valid Hash-compatible class names.
         #
-        # @param default_hash_mode_class_names [Servactory::Configuration::HashMode::ClassNamesCollection]
-        #   Hash-like types to accept
+        # @param default_hash_mode_class_names [Array<Class>] Hash-like types to accept
         # @return [void]
         def assign(default_hash_mode_class_names)
           @default_hash_mode_class_names = default_hash_mode_class_names
@@ -279,7 +277,7 @@ module Servactory
             return true
           end
 
-          value = object.fetch(schema_key, nil)
+          value = object[schema_key]
           prepared_value = prepare_value_from(schema_value:, value:, required: attribute_required)
 
           [
@@ -299,7 +297,7 @@ module Servactory
           required || (
             !required && !fetch_default_from(schema_value).nil?
           ) || (
-            !required && !object.fetch(schema_key, nil).nil?
+            !required && !object[schema_key].nil?
           )
         end
 
@@ -322,7 +320,7 @@ module Servactory
         # @param value [Hash] Schema definition
         # @return [Object, nil] Default value or nil
         def fetch_default_from(value)
-          value.fetch(:default, nil)
+          value[:default]
         end
 
         ########################################################################
@@ -354,14 +352,14 @@ module Servactory
               )
             else
               # Apply scalar defaults.
-              default_value = schema_value.fetch(:default, nil)
+              default_value = schema_value[:default]
 
               if !required && !default_value.nil? && !Servactory::Utils.value_present?(object_value)
                 object[schema_key] = default_value
               end
 
               # Execute prepare callback if defined.
-              unless (input_prepare = schema_value.fetch(:prepare, nil)).nil?
+              unless (input_prepare = schema_value[:prepare]).nil?
                 object[schema_key] = input_prepare.call(value: object[schema_key])
               end
 

data/lib/servactory/utils.rb

@@ -12,14 +12,6 @@ module Servactory
       data.symbolize_keys
     end
 
-    def fetch_hash_with_desired_attribute(attribute)
-      return { input: attribute.class::Actor.new(attribute) } if really_input?(attribute)
-      return { internal: attribute.class::Actor.new(attribute) } if really_internal?(attribute)
-      return { output: attribute.class::Actor.new(attribute) } if really_output?(attribute)
-
-      raise ArgumentError, "Failed to define attribute"
-    end
-
     def define_attribute_with(input: nil, internal: nil, output: nil)
       return input if really_input?(input)
       return internal if really_internal?(internal)

data/lib/servactory/version.rb

@@ -3,9 +3,9 @@
 module Servactory
   module VERSION
     MAJOR = 3
-    MINOR = 0
-    PATCH = 4
-    PRE = nil
+    MINOR = 1
+    PATCH = 0
+    PRE = "rc1"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

data/lib/servactory.rb

@@ -16,6 +16,10 @@ loader.inflector.inflect(
 )
 loader.setup
 
+# Eager load DSL to initialize Stroma::Registry.
+# Registry must be populated before any service class is defined.
+require_relative "servactory/dsl"
+
 module Servactory; end
 
 require "servactory/engine" if defined?(Rails::Engine)