servactory 2.3.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9598623fa8187288fe92566315cf8bf293f0fec4995cd778186b7b29bba90504
-  data.tar.gz: 03d3236b8b846e1fecc11ee19d754a235c5b40a9b7d58f36298767a2ea36b241
+  metadata.gz: 3996c6a138a1683fe3e46b04e9a57f9e135c93f3fd3855287374595e3b3111b3
+  data.tar.gz: 72e31e10893e67f5fd57ce54f0241ac35720071d6b1837bda85a953e717c8ae5
 SHA512:
-  metadata.gz: 9a56ab102855338ee035e6b4163af6e39d618ea56c3a8277b9f6bae7c5974d203ade30db911ed32a0cad0c541e8f2b3e7dced9fb7015ee905e0e15ef66b06094
-  data.tar.gz: c2d2014270e95e382de071858c8ce43f555c6b05d019f24b30f824fad934c63cd849b837813dbe53faf5afde8b6da4cb32d5f7ee72c6074ccc275d4a2a0dc453
+  metadata.gz: ec9727d9cd881bfb898f6843488fe7676ba18746ae40fd88e6feb391352c2e6eebf89137ca7d0743577d92caadde20a673973268040c2482eece16af82db2d5b
+  data.tar.gz: a73916a75bcd4b681ad41fc23ba63546d1a7ae46ff738eeb0f36671f191bd1195c64778e9ea7ddbec80a06c0c14dd46741b43bd521c09a94f9b6eb0cc395ab1f

data/config/locales/en.yml

@@ -16,7 +16,16 @@ en:
           default_error: "[%{service_class_name}] Wrong value in `%{input_name}`, must be one of `%{input_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Input `%{input_name}` must \"%{code}\""
-          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{input_name}` input"
+          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{input_name}` input: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Input `%{input_name}` does not match `%{format_name}` format"
+              wrong_pattern: "[%{service_class_name}] Input `%{input_name}` does not match `%{format_name}` format"
+              unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for input `%{input_name}`"
+            min:
+              default: "[%{service_class_name}] Input `%{input_name}` received value `%{value}`, which is less than `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Input `%{input_name}` received value `%{value}`, which is greater than `%{option_value}`"
         required:
           default_error:
             default: "[%{service_class_name}] Required input `%{input_name}` is missing"
@@ -25,6 +34,7 @@ en:
           default_error:
             default: "[%{service_class_name}] Wrong type of input `%{input_name}`, expected `%{expected_type}`, got `%{given_type}`"
             for_collection:
+              wrong_type: "[%{service_class_name}] Wrong input collection type `%{input_name}`, expected `%{expected_type}`, got `%{given_type}`"
               wrong_element_type: "[%{service_class_name}] Wrong type in input collection `%{input_name}`, expected `%{expected_type}`, got `%{given_type}`"
             for_hash:
               wrong_element_type: "[%{service_class_name}] Wrong type in input hash `%{input_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
@@ -42,7 +52,16 @@ en:
           default_error: "[%{service_class_name}] Wrong value in `%{internal_name}`, must be one of `%{internal_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Internal attribute `%{internal_name}` must \"%{code}\""
-          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{internal_name}` internal attribute"
+          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{internal_name}` internal attribute: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Internal attribute `%{internal_name}` does not match `%{format_name}` format"
+              wrong_pattern: "[%{service_class_name}] Internal attribute `%{internal_name}` does not match `%{format_name}` format"
+              unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for output attribute `%{internal_name}`"
+            min:
+              default: "[%{service_class_name}] Internal attribute `%{internal_name}` received value `%{value}`, which is less than `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Internal attribute `%{internal_name}` received value `%{value}`, which is greater than `%{option_value}`"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of internal attribute `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
@@ -60,7 +79,16 @@ en:
           default_error: "[%{service_class_name}] Wrong value in `%{output_name}`, must be one of `%{output_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Output attribute `%{output_name}` must \"%{code}\""
-          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{output_name}` output attribute"
+          syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{output_name}` output attribute: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Output attribute `%{output_name}` does not match `%{format_name}` format"
+              wrong_pattern: "[%{service_class_name}] Output attribute `%{output_name}` does not match `%{format_name}` format"
+              unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for output attribute `%{output_name}`"
+            min:
+              default: "[%{service_class_name}] Output attribute `%{output_name}` received value `%{value}`, which is less than `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Output attribute `%{output_name}` received value `%{value}`, which is greater than `%{option_value}`"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of output attribute `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"

data/config/locales/ru.yml

@@ -16,7 +16,16 @@ ru:
           default_error: "[%{service_class_name}] Неправильное значение в `%{input_name}`, должно быть одним из `%{input_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Инпут `%{input_name}` должен \"%{code}\""
-          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` инпута `%{input_name}`"
+          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` инпута `%{input_name}`: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Инпут `%{input_name}` не соответствует формату `%{format_name}`"
+              wrong_pattern: "[%{service_class_name}] Инпут `%{input_name}` не соответствует формату `%{format_name}`"
+              unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у инпута `%{input_name}`"
+            min:
+              default: "[%{service_class_name}] Инпут `%{input_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Инпут `%{input_name}` получил значение `%{value}`, которое больше `%{option_value}`"
         required:
           default_error:
             default: "[%{service_class_name}] Обязательный инпут `%{input_name}` отсутствует"
@@ -25,6 +34,7 @@ ru:
           default_error:
             default: "[%{service_class_name}] Неправильный тип инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
             for_collection:
+              wrong_type: "[%{service_class_name}] Неправильный тип коллекции инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
               wrong_element_type: "[%{service_class_name}] Неправильный тип в коллекции инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
             for_hash:
               wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше инпута `%{input_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
@@ -43,7 +53,16 @@ ru:
           default_error: "[%{service_class_name}] Неправильное значение в `%{internal_name}`, должно быть одним из `%{internal_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` должен \"%{code}\""
-          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` внутреннего атрибута `%{internal_name}`"
+          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` внутреннего атрибута `%{internal_name}`: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` не соответствует формату `%{format_name}`"
+              wrong_pattern: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` не соответствует формату `%{format_name}`"
+              unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у внутреннего атрибута `%{internal_name}`"
+            min:
+              default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` получил значение `%{value}`, которое больше `%{option_value}`"
         type:
           default_error:
             default: "[%{service_class_name}] Неправильный тип внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
@@ -61,7 +80,16 @@ ru:
           default_error: "[%{service_class_name}] Неправильное значение в `%{output_name}`, должно быть одним из `%{output_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Выходящий атрибут `%{output_name}` должен \"%{code}\""
-          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` выходящего атрибута `%{output_name}`"
+          syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` выходящего атрибута `%{output_name}`: %{exception_message}"
+          dynamic_options:
+            format:
+              default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` не соответствует формату `%{format_name}`"
+              wrong_pattern: "[%{service_class_name}] Выходящий атрибут `%{output_name}` не соответствует формату `%{format_name}`"
+              unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у выходящего атрибута `%{output_name}`"
+            min:
+              default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
+            max:
+              default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` получил значение `%{value}`, которое больше `%{option_value}`"
         type:
           default: "[%{service_class_name}] Неправильный тип выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
           for_collection:

data/lib/servactory/context/callable.rb

@@ -3,26 +3,43 @@
 module Servactory
   module Context
     module Callable
-      def call!(arguments = {}) # rubocop:disable Metrics/MethodLength
+      def call!(arguments = {})
+        prepare_result_class
+
         context = send(:new)
 
-        context.send(
-          :_call!,
-          incoming_arguments: arguments.symbolize_keys,
-          collection_of_inputs: collection_of_inputs,
-          collection_of_internals: collection_of_internals,
-          collection_of_outputs: collection_of_outputs,
-          collection_of_stages: collection_of_stages
-        )
+        _call!(context, **arguments)
 
-        Servactory::Result.success_for(context: context)
+        self::Result.success_for(context: context)
       rescue config.success_class => e
-        Servactory::Result.success_for(context: e.context)
+        self::Result.success_for(context: e.context)
       end
 
       def call(arguments = {})
+        prepare_result_class
+
         context = send(:new)
 
+        _call!(context, **arguments)
+
+        self::Result.success_for(context: context)
+      rescue config.success_class => e
+        self::Result.success_for(context: e.context)
+      rescue config.failure_class => e
+        self::Result.failure_for(exception: e)
+      end
+
+      private
+
+      def prepare_result_class
+        return if Object.const_defined?("#{name}::Result")
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          Result = Class.new(Servactory::Result)
+        RUBY
+      end
+
+      def _call!(context, **arguments)
         context.send(
           :_call!,
           incoming_arguments: arguments.symbolize_keys,
@@ -31,12 +48,6 @@ module Servactory
           collection_of_outputs: collection_of_outputs,
           collection_of_stages: collection_of_stages
         )
-
-        Servactory::Result.success_for(context: context)
-      rescue config.success_class => e
-        Servactory::Result.success_for(context: e.context)
-      rescue config.failure_class => e
-        Servactory::Result.failure_for(exception: e)
       end
     end
   end

data/lib/servactory/context/store.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    class Store
+      def initialize(context)
+        @context = context
+      end
+
+      def fetch_internal(name)
+        internals.fetch(name, nil)
+      end
+
+      def assign_internal(name, value)
+        assign_attribute(:internals, name, value)
+      end
+
+      def fetch_output(name)
+        outputs.fetch(name, nil)
+      end
+
+      def assign_output(name, value)
+        assign_attribute(:outputs, name, value)
+      end
+
+      def outputs
+        @outputs ||= context_data.fetch(:outputs)
+      end
+
+      private
+
+      def assign_attribute(section, name, value)
+        context_data[section].merge!({ name => value })
+      end
+
+      def internals
+        @internals ||= context_data.fetch(:internals)
+      end
+
+      def context_data
+        @context_data ||= state.fetch(context_id)
+      end
+
+      def state
+        {
+          context_id => {
+            internals: {},
+            outputs: {}
+          }
+        }
+      end
+
+      def context_id
+        @context_id ||= "context_#{@context.object_id}"
+      end
+    end
+  end
+end

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

@@ -50,7 +50,7 @@ module Servactory
             value: value
           )
 
-          @context.send(:assign_servactory_service_storage_internal, internal.name, value)
+          @context.send(:servactory_service_store).assign_internal(internal.name, value)
         end
 
         def getter_with(name:, &block) # rubocop:disable Lint/UnusedMethodArgument
@@ -59,7 +59,7 @@ module Servactory
 
           return yield if internal.nil?
 
-          internal_value = @context.send(:fetch_servactory_service_storage_internal, internal.name)
+          internal_value = @context.send(:servactory_service_store).fetch_internal(internal.name)
 
           if name.to_s.end_with?("?")
             Servactory::Utils.query_attribute(internal_value)

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

@@ -50,7 +50,7 @@ module Servactory
             value: value
           )
 
-          @context.send(:assign_servactory_service_storage_output, output.name, value)
+          @context.send(:servactory_service_store).assign_output(output.name, value)
         end
 
         def getter_with(name:, &block) # rubocop:disable Lint/UnusedMethodArgument
@@ -59,7 +59,7 @@ module Servactory
 
           return yield if output.nil?
 
-          output_value = @context.send(:fetch_servactory_service_storage_output, output.name)
+          output_value = @context.send(:servactory_service_store).fetch_output(output.name)
 
           if name.to_s.end_with?("?")
             Servactory::Utils.query_attribute(output_value)

data/lib/servactory/context/workspace.rb

@@ -2,7 +2,7 @@
 
 module Servactory
   module Context
-    module Workspace # rubocop:disable Metrics/ModuleLength
+    module Workspace
       def inputs
         @inputs ||= Inputs.new(
           context: self,
@@ -29,24 +29,27 @@ module Servactory
         raise self.class.config.success_class.new(context: self)
       end
 
-      def fail_input!(input_name, message:)
+      def fail_input!(input_name, message:, meta: nil)
         raise self.class.config.input_exception_class.new(
           input_name: input_name,
-          message: message
+          message: message,
+          meta: meta
         )
       end
 
-      def fail_internal!(internal_name, message:)
+      def fail_internal!(internal_name, message:, meta: nil)
         raise self.class.config.internal_exception_class.new(
           internal_name: internal_name,
-          message: message
+          message: message,
+          meta: meta
         )
       end
 
-      def fail_output!(output_name, message:)
+      def fail_output!(output_name, message:, meta: nil)
         raise self.class.config.output_exception_class.new(
           output_name: output_name,
-          message: message
+          message: message,
+          meta: meta
         )
       end
 
@@ -104,24 +107,8 @@ module Servactory
         )
       end
 
-      def servactory_service_storage
-        @servactory_service_storage ||= { internals: {}, outputs: {} }
-      end
-
-      def assign_servactory_service_storage_internal(key, value)
-        servactory_service_storage[:internals].merge!({ key => value })
-      end
-
-      def fetch_servactory_service_storage_internal(key)
-        servactory_service_storage.fetch(:internals).fetch(key, nil)
-      end
-
-      def assign_servactory_service_storage_output(key, value)
-        servactory_service_storage[:outputs].merge!({ key => value })
-      end
-
-      def fetch_servactory_service_storage_output(key)
-        servactory_service_storage.fetch(:outputs).fetch(key, nil)
+      def servactory_service_store
+        @servactory_service_store ||= Store.new(self)
       end
     end
   end

data/lib/servactory/errors/input_error.rb

@@ -5,11 +5,13 @@ module Servactory
     # DEPRECATED: This class will be deleted after release 2.4.
     class InputError < Servactory::Exceptions::Base
       attr_reader :message,
-                  :input_name
+                  :input_name,
+                  :meta
 
-      def initialize(message:, input_name: nil)
+      def initialize(message:, input_name: nil, meta: nil)
         @message = message
         @input_name = input_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/errors/internal_error.rb

@@ -5,11 +5,13 @@ module Servactory
     # DEPRECATED: This class will be deleted after release 2.4.
     class InternalError < Servactory::Exceptions::Base
       attr_reader :message,
-                  :internal_name
+                  :internal_name,
+                  :meta
 
-      def initialize(message:, internal_name: nil)
+      def initialize(message:, internal_name: nil, meta: nil)
         @message = message
         @internal_name = internal_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/errors/output_error.rb

@@ -5,11 +5,13 @@ module Servactory
     # DEPRECATED: This class will be deleted after release 2.4.
     class OutputError < Servactory::Exceptions::Base
       attr_reader :message,
-                  :output_name
+                  :output_name,
+                  :meta
 
-      def initialize(message:, output_name: nil)
+      def initialize(message:, output_name: nil, meta: nil)
         @message = message
         @output_name = output_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/exceptions/input.rb

@@ -4,11 +4,13 @@ module Servactory
   module Exceptions
     class Input < Base
       attr_reader :message,
-                  :input_name
+                  :input_name,
+                  :meta
 
-      def initialize(message:, input_name: nil)
+      def initialize(message:, input_name: nil, meta: nil)
         @message = message
         @input_name = input_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/exceptions/internal.rb

@@ -4,11 +4,13 @@ module Servactory
   module Exceptions
     class Internal < Base
       attr_reader :message,
-                  :internal_name
+                  :internal_name,
+                  :meta
 
-      def initialize(message:, internal_name: nil)
+      def initialize(message:, internal_name: nil, meta: nil)
         @message = message
         @internal_name = internal_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/exceptions/output.rb

@@ -4,11 +4,13 @@ module Servactory
   module Exceptions
     class Output < Base
       attr_reader :message,
-                  :output_name
+                  :output_name,
+                  :meta
 
-      def initialize(message:, output_name: nil)
+      def initialize(message:, output_name: nil, meta: nil)
         @message = message
         @output_name = output_name&.to_sym
+        @meta = meta
 
         super(message)
       end

data/lib/servactory/inputs/input.rb

@@ -3,6 +3,29 @@
 module Servactory
   module Inputs
     class Input
+      class Work
+        attr_reader :name,
+                    :internal_name,
+                    :types,
+                    :inclusion
+
+        def initialize(input) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          @name = input.name
+          @internal_name = input.internal_name
+          @types = input.types
+          @inclusion = input.inclusion.slice(:in) if input.inclusion_present?
+
+          define_singleton_method(:system_name) { input.system_name }
+          define_singleton_method(:i18n_name) { input.i18n_name }
+          define_singleton_method(:optional?) { input.optional? }
+          define_singleton_method(:required?) { input.required? }
+          # The methods below are required to support the internal work.
+          define_singleton_method(:input?) { true }
+          define_singleton_method(:internal?) { false }
+          define_singleton_method(:output?) { false }
+        end
+      end
+
       attr_reader :name,
                   :internal_name,
                   :collection_of_options
@@ -40,7 +63,10 @@ module Servactory
       end
 
       def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
+        advanced_helpers = options.except(*Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS)
+
         options = apply_helpers_for_options(helpers: helpers, options: options) if helpers.present?
+        options = apply_helpers_for_options(helpers: advanced_helpers, options: options) if advanced_helpers.present?
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
@@ -62,15 +88,22 @@ module Servactory
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:)
+      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
         prepared_options = {}
 
-        helpers.each do |helper|
+        helpers.each do |(helper, values)|
           found_helper = @option_helpers.find_by(name: helper)
 
           next if found_helper.blank?
 
-          prepared_options.merge!(found_helper.equivalent)
+          prepared_option =
+            if found_helper.equivalent.is_a?(Proc)
+              values.is_a?(Hash) ? found_helper.equivalent.call(**values) : found_helper.equivalent.call(values)
+            else
+              found_helper.equivalent
+            end
+
+          prepared_options.deep_merge!(prepared_option)
         end
 
         options.merge(prepared_options)

data/lib/servactory/internals/internal.rb

@@ -3,6 +3,25 @@
 module Servactory
   module Internals
     class Internal
+      class Work
+        attr_reader :name,
+                    :types,
+                    :inclusion
+
+        def initialize(internal)
+          @name = internal.name
+          @types = internal.types
+          @inclusion = internal.inclusion.slice(:in) if internal.inclusion_present?
+
+          define_singleton_method(:system_name) { internal.system_name }
+          define_singleton_method(:i18n_name) { internal.i18n_name }
+          # The methods below are required to support the internal work.
+          define_singleton_method(:input?) { false }
+          define_singleton_method(:internal?) { true }
+          define_singleton_method(:output?) { false }
+        end
+      end
+
       attr_reader :name,
                   :collection_of_options
 
@@ -35,7 +54,10 @@ module Servactory
       end
 
       def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
+        advanced_helpers = options.except(*Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS)
+
         options = apply_helpers_for_options(helpers: helpers, options: options) if helpers.present?
+        options = apply_helpers_for_options(helpers: advanced_helpers, options: options) if advanced_helpers.present?
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
@@ -54,15 +76,22 @@ module Servactory
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:)
+      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
         prepared_options = {}
 
-        helpers.each do |helper|
+        helpers.each do |(helper, values)|
           found_helper = @option_helpers.find_by(name: helper)
 
           next if found_helper.blank?
 
-          prepared_options.merge!(found_helper.equivalent)
+          prepared_option =
+            if found_helper.equivalent.is_a?(Proc)
+              values.is_a?(Hash) ? found_helper.equivalent.call(**values) : found_helper.equivalent.call(values)
+            else
+              found_helper.equivalent
+            end
+
+          prepared_options.deep_merge!(prepared_option)
         end
 
         options.merge(prepared_options)

data/lib/servactory/maintenance/attributes/options/registrar.rb

@@ -5,6 +5,17 @@ module Servactory
     module Attributes
       module Options
         class Registrar # rubocop:disable Metrics/ClassLength
+          RESERVED_OPTIONS = %i[
+            type
+            required
+            default
+            collection
+            hash
+            inclusion
+            must
+            prepare
+          ].freeze
+
           DEFAULT_FEATURES = {
             required: false,
             types: false,
@@ -121,7 +132,10 @@ module Servactory
               define_methods: [
                 Servactory::Maintenance::Attributes::DefineMethod.new(
                   name: :collection_mode?,
-                  content: ->(**) { @collection_mode_class_names.include?(@options.fetch(:type)) }
+                  content: lambda do |**|
+                    @collection_mode_class_names.include?(@options.fetch(:type)) &&
+                      @options.fetch(:consists_of, true) != false
+                  end
                 )
               ],
               define_conflicts: [

data/lib/servactory/maintenance/attributes/translator/must.rb

@@ -7,8 +7,8 @@ module Servactory
         module Must
           module_function
 
-          def default_message
-            lambda do |service_class_name:, value:, code:, input: nil, internal: nil, output: nil|
+          def default_message # rubocop:disable Metrics/MethodLength
+            lambda do |service_class_name:, value:, code:, input: nil, internal: nil, output: nil, reason: nil|
               attribute = Servactory::Utils.define_attribute_with(input: input, internal: internal, output: output)
 
               I18n.t(
@@ -16,7 +16,8 @@ module Servactory
                 service_class_name: service_class_name,
                 "#{attribute.system_name}_name": attribute.name,
                 value: value,
-                code: code
+                code: code,
+                reason: reason
               )
             end
           end