servactory 3.0.0.rc3 → 3.0.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5972f03405d88ae923f1e000479449e281af67b9d22b52010d2131dc1023cc15
-  data.tar.gz: 6c7c495d158deee0453114fb637897a2431d7ce4efc4e522a0716ec28a7dd89b
+  metadata.gz: 4c94166cc0d29f50acac299374f644be29db0b4ee533ca49c7f9e0ec698c32a6
+  data.tar.gz: 022a3b05c74fbef3005fd6ec7cc09b9d3b8459d5544578bc09731e9d8378f2e5
 SHA512:
-  metadata.gz: 82e84edd70b3ee47a91944bd60e5d9bec1cf33b18ca5d008d40973685c796cfa31b48de2f0599764c864db535959cd86a073ed30725c1fe1af49a98ce4bd72ab
-  data.tar.gz: 585a53ba4491246e5e4aaec23568e074a2d142d467b9d44bc551d629bce2047fcfd99d89c0bdcb897e9a28e9f7037b9128396107fe6c01083ff0b4298ee11f71
+  metadata.gz: f411d897f5885d6b783c9b5531c6ae1b71d0b681b8249d635bf8e6152613bb43630f6705674f33cb54351daa9f207352fb2ab23b488629a05a5bfc4a44329e01
+  data.tar.gz: db0bd759b7e7da5c50a3283b144a8ba8ba1a58ce6fa3fd7c91709e46adcaa661fce2103d03fe2e70a59ba37906f984c8c4944bf54d54aa00a8832b76552e7b83

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

@@ -3,19 +3,35 @@
 module Servactory
   module Context
     module Warehouse
+      # Base class for warehouse storage views.
+      #
+      # ## Purpose
+      #
+      # Provides common fetch and assign operations for all warehouse
+      # view classes (Inputs, Internals, Outputs).
       class Base
+        # Creates base view with storage hash reference.
+        #
+        # @param arguments [Hash] Reference to Crate data
+        # @return [Base] New base view
         def initialize(arguments = {})
           @arguments = arguments
         end
 
-        # def fetch!(name)
-        #   @arguments.fetch(name)
-        # end
-
+        # Retrieves value by name with default fallback.
+        #
+        # @param name [Symbol] Key name
+        # @param default_value [Object] Value if not found
+        # @return [Object] Stored or default value
         def fetch(name, default_value)
           @arguments.fetch(name, default_value)
         end
 
+        # Stores value by key.
+        #
+        # @param key [Symbol] Key name
+        # @param value [Object] Value to store
+        # @return [Object] Stored value
         def assign(key, value)
           @arguments[key] = value
         end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      # Unified crate for service context data.
+      #
+      # ## Purpose
+      #
+      # Crate provides a single object that holds all three data sections
+      # (inputs, internals, outputs) in separate hashes. This reduces object
+      # allocations compared to creating separate warehouse instances.
+      #
+      # ## Usage
+      #
+      # Crate is used internally by Setup class:
+      #
+      # ```ruby
+      # crate = Crate.new
+      # crate.inputs[:name] = "value"
+      # crate.outputs[:result] = result
+      # ```
+      class Crate
+        attr_reader :inputs,
+                    :internals,
+                    :outputs
+
+        # Creates new crate with empty sections.
+        #
+        # @return [Crate] New crate instance
+        def initialize
+          @inputs = {}
+          @internals = {}
+          @outputs = {}
+        end
+      end
+    end
+  end
+end

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

@@ -3,41 +3,72 @@
 module Servactory
   module Context
     module Warehouse
+      # View for accessing service input values.
+      #
+      # ## Purpose
+      #
+      # Inputs provides access to service input data with dynamic method access,
+      # predicate support, and error handling. It references Crate data
+      # instead of creating its own.
       class Inputs < Base
-        def initialize(context, arguments = {})
+        # Creates inputs view referencing Crate data.
+        #
+        # @param context [Object] Service context for error handling
+        # @param arguments [Hash] Reference to Crate#inputs
+        # @return [Inputs] New inputs view
+        def initialize(context, arguments)
           @context = context
 
           super(arguments)
         end
 
+        # Returns array of input names.
+        #
+        # @return [Array<Symbol>] Input names
         def names
           @arguments.keys
         end
 
+        # Merges new arguments into storage.
+        #
+        # @param arguments [Hash] Input name-value pairs to merge
+        # @return [Hash] Updated arguments hash
         def merge!(arguments)
           @arguments.merge!(arguments)
         end
 
-        ##########################################################################
-
+        # Delegates method calls to stored inputs.
+        #
+        # 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
         def method_missing(name, *_args)
-          input_name = @context.config.predicate_methods_enabled ? name.to_s.chomp("?").to_sym : name
+          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) }
 
-          if name.to_s.end_with?("?") && @context.config.predicate_methods_enabled
-            Servactory::Utils.query_attribute(input_value)
-          else
-            input_value
-          end
+          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
         end
 
+        # 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) }
         end
 
-        ##########################################################################
+        private
 
+        # Raises error for undefined input.
+        #
+        # @param input_name [Symbol] Name of undefined input
+        # @raise [Exception] Failure exception with localized message
         def raise_error_for(input_name)
           message_text = @context.send(:servactory_service_info).translate(
             "inputs.undefined.for_fetch",

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

@@ -3,8 +3,13 @@
 module Servactory
   module Context
     module Warehouse
-      class Internals < Base
-      end
+      # View for accessing service internal values.
+      #
+      # ## Purpose
+      #
+      # Internals provides simple key-value storage for intermediate
+      # service state. It references Crate data.
+      class Internals < Base; end
     end
   end
 end

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

@@ -3,6 +3,13 @@
 module Servactory
   module Context
     module Warehouse
+      # View for accessing service output values.
+      #
+      # ## Purpose
+      #
+      # Outputs provides storage for service result values with iteration
+      # support via each_pair delegation. Used by Result class to build
+      # output hash.
       class Outputs < Base
         extend Forwardable
 

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

@@ -3,69 +3,92 @@
 module Servactory
   module Context
     module Warehouse
+      # Orchestrator for service context data.
+      #
+      # ## Purpose
+      #
+      # Setup manages a unified Crate instance and provides the public
+      # interface for accessing inputs, internals, and outputs. It creates
+      # view objects lazily on first access.
       class Setup
+        # Creates setup with unified crate.
+        #
+        # @param context [Object] Service context
+        # @return [Setup] New setup instance
         def initialize(context)
           @context = context
+          @crate = Crate.new
         end
 
+        # Merges input arguments into storage.
+        #
+        # @param arguments [Hash] Input name-value pairs
+        # @return [Hash] Updated inputs hash
         def assign_inputs(arguments)
-          context_data[:inputs].merge!(arguments)
+          inputs.merge!(arguments)
         end
 
+        # Retrieves input value by name.
+        #
+        # @param name [Symbol] Input name
+        # @return [Object, nil] Input value or nil
         def fetch_input(name)
           inputs.fetch(name, nil)
         end
 
+        # Stores internal value by name.
+        #
+        # @param name [Symbol] Internal name
+        # @param value [Object] Value to store
+        # @return [Object] Stored value
         def assign_internal(name, value)
-          assign_attribute(:internals, name, value)
+          internals.assign(name, value)
         end
 
+        # Retrieves internal value by name.
+        #
+        # @param name [Symbol] Internal name
+        # @return [Object, nil] Internal value or nil
         def fetch_internal(name)
           internals.fetch(name, nil)
         end
 
+        # Stores output value by name.
+        #
+        # @param name [Symbol] Output name
+        # @param value [Object] Value to store
+        # @return [Object] Stored value
         def assign_output(name, value)
-          assign_attribute(:outputs, name, value)
+          outputs.assign(name, value)
         end
 
+        # Retrieves output value by name.
+        #
+        # @param name [Symbol] Output name
+        # @return [Object, nil] Output value or nil
         def fetch_output(name)
           outputs.fetch(name, nil)
         end
 
+        # Returns inputs view object.
+        #
+        # @return [Inputs] Inputs view
         def inputs
-          @inputs ||= context_data.fetch(:inputs)
+          @inputs ||= Inputs.new(@context, @crate.inputs)
         end
 
+        # Returns internals view object.
+        #
+        # @return [Internals] Internals view
         def internals
-          @internals ||= context_data.fetch(:internals)
+          @internals ||= Internals.new(@crate.internals)
         end
 
+        # Returns outputs view object.
+        #
+        # @return [Outputs] Outputs view
         def outputs
-          @outputs ||= context_data.fetch(:outputs)
-        end
-
-        private
-
-        def assign_attribute(section, name, value)
-          context_data[section].assign(name, value)
-        end
-
-        def context_data
-          @context_data ||= state.fetch(context_id)
-        end
-
-        def state
-          {
-            context_id => {
-              inputs: Servactory::Context::Warehouse::Inputs.new(@context),
-              internals: Servactory::Context::Warehouse::Internals.new,
-              outputs: Servactory::Context::Warehouse::Outputs.new
-            }
-          }
-        end
-
-        def context_id
-          @context_id ||= "context_#{@context.object_id}"
+          @outputs ||= Outputs.new(@crate.outputs)
         end
       end
     end

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

@@ -39,7 +39,9 @@ module Servactory
 
         # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
         def fetch_with(name:, &block)
-          input_name = @context.config.predicate_methods_enabled ? name.to_s.chomp("?").to_sym : name
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
+          input_name = predicate ? name.to_s.chomp("?").to_sym : name
 
           input = @collection_of_inputs.find_by(name: input_name)
 
@@ -51,14 +53,10 @@ module Servactory
             input_value = input.default
           end
 
-          input_prepare = input.prepare.fetch(:in, nil)
-          input_value = input_prepare.call(value: input_value) if input_prepare.present?
+          input_prepare = input.prepare[:in]
+          input_value = input_prepare.call(value: input_value) if input_prepare
 
-          if name.to_s.end_with?("?") && @context.config.predicate_methods_enabled
-            Servactory::Utils.query_attribute(input_value)
-          else
-            input_value
-          end
+          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
         end
         # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
 

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

@@ -53,8 +53,10 @@ module Servactory
           @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Lint/UnusedMethodArgument
-          internal_name = @context.config.predicate_methods_enabled ? name.to_s.chomp("?").to_sym : name
+        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)
 
           return yield if internal.nil?
@@ -67,11 +69,7 @@ module Servactory
             value: internal_value
           )
 
-          if name.to_s.end_with?("?") && @context.config.predicate_methods_enabled
-            Servactory::Utils.query_attribute(internal_value)
-          else
-            internal_value
-          end
+          predicate ? Servactory::Utils.query_attribute(internal_value) : internal_value
         end
 
         def raise_error_for(type, name)

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

@@ -53,19 +53,17 @@ module Servactory
           @context.send(:servactory_service_warehouse).assign_output(output.name, value)
         end
 
-        def fetch_with(name:, &block) # rubocop:disable Metrics/AbcSize, Lint/UnusedMethodArgument
-          output_name = @context.config.predicate_methods_enabled ? name.to_s.chomp("?").to_sym : name
+        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)
 
-          if name.to_s.end_with?("?") && @context.config.predicate_methods_enabled
-            Servactory::Utils.query_attribute(output_value)
-          else
-            output_value
-          end
+          predicate ? Servactory::Utils.query_attribute(output_value) : output_value
         end
 
         def raise_error_for(type, name)

data/lib/servactory/inputs/input.rb

@@ -16,27 +16,37 @@ module Servactory
           @types = input.types
           @default = input.default
           @options = input.options
+          @attribute = input
+        end
+
+        def system_name
+          @attribute.system_name
+        end
+
+        def i18n_name
+          @attribute.i18n_name
+        end
+
+        def optional?
+          @attribute.optional?
+        end
+
+        def required?
+          @attribute.required?
+        end
+
+        # The methods below are required to support the internal work.
+
+        def input?
+          true
+        end
 
-          define_identity_methods(input)
+        def internal?
+          false
         end
 
-        private
-
-        def define_identity_methods(input) # rubocop:disable Metrics/MethodLength
-          methods_map = {
-            system_name: -> { input.system_name },
-            i18n_name: -> { input.i18n_name },
-            optional?: -> { input.optional? },
-            required?: -> { input.required? },
-            # The methods below are required to support the internal work.
-            input?: -> { true },
-            internal?: -> { false },
-            output?: -> { false }
-          }
-
-          methods_map.each do |method_name, implementation|
-            define_singleton_method(method_name, &implementation)
-          end
+        def output?
+          false
         end
       end
 

data/lib/servactory/inputs/tools/validation.rb

@@ -11,11 +11,13 @@ module Servactory
         def initialize(context, collection_of_inputs)
           @context = context
           @collection_of_inputs = collection_of_inputs
+          @first_error = nil
         end
 
         def validate!
           @collection_of_inputs.each do |input|
             process_input(input)
+            break if @first_error.present?
           end
 
           raise_errors
@@ -26,6 +28,7 @@ module Servactory
         def process_input(input)
           input.options_for_checks.each do |check_key, check_options|
             process_option(check_key, check_options, input:)
+            break if @first_error.present?
           end
         end
 
@@ -34,16 +37,17 @@ module Servactory
           return if validation_classes.empty?
 
           validation_classes.each do |validation_class|
-            errors_from_checks = process_validation_class(
+            error_message = process_validation_class(
               validation_class:,
               input:,
               check_key:,
               check_options:
             )
 
-            next if errors_from_checks.nil? || errors_from_checks.empty?
+            next if error_message.blank?
 
-            errors.merge(errors_from_checks.to_a)
+            @first_error = error_message
+            break
           end
         end
 
@@ -70,14 +74,10 @@ module Servactory
 
         ########################################################################
 
-        def errors
-          @errors ||= Servactory::Maintenance::Attributes::Tools::CheckErrors.new
-        end
-
         def raise_errors
-          return if (tmp_errors = errors.not_blank).empty?
+          return if @first_error.nil?
 
-          @context.fail_input!(nil, message: tmp_errors.first)
+          @context.fail_input!(nil, message: @first_error)
         end
       end
     end

data/lib/servactory/inputs/validations/required.rb

@@ -3,45 +3,69 @@
 module Servactory
   module Inputs
     module Validations
-      class Required < Base
+      # Validates that required inputs have non-empty values.
+      #
+      # ## Purpose
+      #
+      # Required validator ensures that inputs marked as `required: true`
+      # have meaningful values. It checks for presence using `value_present?`
+      # which handles nil, empty strings, and blank values.
+      #
+      # ## Usage
+      #
+      # This validator is automatically applied to inputs with `required: true`:
+      #
+      # ```ruby
+      # class MyService < ApplicationService::Base
+      #   input :email, type: String, required: true
+      #   input :name, type: String, required: { message: "Name is mandatory" }
+      # end
+      # ```
+      class Required
+        extend Servactory::Maintenance::Attributes::Validations::Concerns::ErrorBuilder
+
+        # Validates that a required input has a present value.
+        #
+        # @param context [Object] Service context for error message formatting
+        # @param attribute [Inputs::Input] Input attribute to validate
+        # @param value [Object] Value to check for presence
+        # @param check_key [Symbol] Must be :required to trigger validation
+        # @return [String, nil] Error message on failure, nil on success
         def self.check(context:, attribute:, value:, check_key:, **)
           return unless should_be_checked_for?(attribute, check_key)
+          return if Servactory::Utils.value_present?(value)
 
-          new(context:, input: attribute, value:).check
+          build_error_message(context:, input: attribute, value:)
         end
 
+        # Determines if validation should run for given input and check key.
+        #
+        # @param input [Inputs::Input] Input to check
+        # @param check_key [Symbol] Current validation check key
+        # @return [Boolean] true if this validator should run
         def self.should_be_checked_for?(input, check_key)
           check_key == :required && input.required?
         end
+        private_class_method :should_be_checked_for?
 
-        ##########################################################################
-
-        def initialize(context:, input:, value:)
-          super()
-
-          @context = context
-          @input = input
-          @value = value
-        end
-
-        def check
-          return if Servactory::Utils.value_present?(@value)
-
-          _, message = @input.required.values_at(:is, :message)
-
-          add_error_with(message)
-        end
-
-        private
+        # Builds error message from validation failure.
+        #
+        # @param context [Object] Service context
+        # @param input [Inputs::Input] Input that failed validation
+        # @param value [Object] The invalid value
+        # @return [String] Processed error message
+        def self.build_error_message(context:, input:, value:)
+          _, message = input.required.values_at(:is, :message)
+          message = message.presence || Servactory::Inputs::Translator::Required.default_message
 
-        def add_error_with(message)
-          add_error(
-            message: message.presence || Servactory::Inputs::Translator::Required.default_message,
-            service: @context.send(:servactory_service_info),
-            input: @input,
-            value: @value
+          process_message(
+            message,
+            service: context.send(:servactory_service_info),
+            input:,
+            value:
           )
         end
+        private_class_method :build_error_message
       end
     end
   end

data/lib/servactory/internals/internal.rb

@@ -12,25 +12,29 @@ module Servactory
           @name = internal.name
           @types = internal.types
           @options = internal.options
+          @attribute = internal
+        end
+
+        def system_name
+          @attribute.system_name
+        end
+
+        def i18n_name
+          @attribute.i18n_name
+        end
+
+        # The methods below are required to support the internal work.
+
+        def input?
+          false
+        end
 
-          define_identity_methods(internal)
+        def internal?
+          true
         end
 
-        private
-
-        def define_identity_methods(internal)
-          methods_map = {
-            system_name: -> { internal.system_name },
-            i18n_name: -> { internal.i18n_name },
-            # The methods below are required to support the internal work.
-            input?: -> { false },
-            internal?: -> { true },
-            output?: -> { false }
-          }
-
-          methods_map.each do |method_name, implementation|
-            define_singleton_method(method_name, &implementation)
-          end
+        def output?
+          false
         end
       end