servactory 2.12.0.rc2 → 2.12.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d25dddc86ece8552d4644707ec8ed928d743287e7b6d8cac5b6651c2f4376b4
-  data.tar.gz: 75954babfecf8c47e89961b6a3795b66264d34c09a9362e6ea30891d2453b156
+  metadata.gz: db0f437672047c90c0b10f79f55c49670ec6c18ea977f3cf0ac2ab5e0b1b5cee
+  data.tar.gz: 5a51217c27c4d0d21d1d2d466450295dc4c6b8fcc7254bf7b82634ffa968b03d
 SHA512:
-  metadata.gz: 3d5e14c6eed833a4e2181cbf68d87a69b869a7b98479402a26feb1b1ab2404cb5d74ec3e9cfa6a858a1b059980d3164bcf6c63c4faaddbf57925363a2cd3588b
-  data.tar.gz: cf7f8c2c6fd19d0f743e610a8de747f00fe0e885aa0c62ff392be27522a2d8d7dc88a8cbdd3916099ca4f21f8efcc5132d0ef3f995e37f8c5993bbca9dc207d6
+  metadata.gz: 62a421c1ee2f2135f5d14fdc11378e05f3dda3ddf5a613af2e0809c40defacad98c3ed7ad06d6cb1c91c1333890cb31687dd8423ac2e2c5658acfc53a62a2885
+  data.tar.gz: 900ab23ae47cd912238476d6945ecc31f9fc43e26378bde0ff3d4e0367c1e8f703006a2d44b5704335ee7b1549ecde596be732c5a12acbabbc94d1ca717dfea0

data/config/locales/en.yml

@@ -34,14 +34,16 @@ en:
               default: "[%{service_class_name}] Input `%{input_name}` has the value `%{value}`, which is not a multiple of `%{option_value}`"
               blank: "[%{service_class_name}] Input `%{input_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Input `%{input_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Wrong type of input `%{input_name}`, expected `%{expected_type}`, got `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Wrong type in input hash `%{input_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Wrong value in input hash `%{input_name}`, expected value of type `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
         required:
           default_error:
             default: "[%{service_class_name}] Required input `%{input_name}` is missing"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of input `%{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}`"
       tools:
         find_unnecessary:
           error: "[%{service_class_name}] Unexpected attributes: `%{unnecessary_attributes}`"
@@ -74,11 +76,13 @@ en:
               default: "[%{service_class_name}] Internal attribute `%{internal_name}` has the value `%{value}`, which is not a multiple of `%{option_value}`"
               blank: "[%{service_class_name}] Internal attribute `%{internal_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Internal attribute `%{internal_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Wrong type of internal attribute `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Wrong type in internal attribute hash `%{internal_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Wrong value in internal attribute hash `%{internal_name}`, expected value of type `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of internal attribute `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
-            for_hash:
-              wrong_element_type: "[%{service_class_name}] Wrong type in internal attribute hash `%{internal_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
     outputs:
       undefined:
         for_fetch: "[%{service_class_name}] Undefined output attribute `%{output_name}`"
@@ -106,8 +110,10 @@ en:
               default: "[%{service_class_name}] Output attribute `%{output_name}` has the value `%{value}`, which is not a multiple of `%{option_value}`"
               blank: "[%{service_class_name}] Output attribute `%{output_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Output attribute `%{output_name}` has an invalid value `%{option_value}` in option `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Wrong type of output attribute `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Wrong type in output attribute hash `%{output_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Wrong value in output attribute hash `%{output_name}`, expected value of type `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of output attribute `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"
-            for_hash:
-              wrong_element_type: "[%{service_class_name}] Wrong type in output attribute hash `%{output_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"

data/config/locales/ru.yml

@@ -34,14 +34,16 @@ ru:
               default: "[%{service_class_name}] Инпут `%{input_name}` имеет значение `%{value}`, которое не кратно `%{option_value}`"
               blank: "[%{service_class_name}] Инпут `%{input_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Инпут `%{input_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Неправильный тип инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше инпута `%{input_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Неправильное значение в хеше инпута `%{input_name}`, для `%{key_name}` ожидалось значение с типом `%{expected_type}`, получено `%{given_type}`"
         required:
           default_error:
             default: "[%{service_class_name}] Обязательный инпут `%{input_name}` отсутствует"
         type:
           default_error:
             default: "[%{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}`"
       tools:
         find_unnecessary:
           error: "[%{service_class_name}] Неожиданные атрибуты: `%{unnecessary_attributes}`"
@@ -74,11 +76,13 @@ ru:
               default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` имеет значение `%{value}`, которое не кратно `%{option_value}`"
               blank: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Неправильный тип внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше внутреннего атрибута `%{internal_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Неправильное значение в хеше внутреннего атрибута `%{internal_name}`, для `%{key_name}` ожидалось значение с типом `%{expected_type}`, получено `%{given_type}`"
         type:
           default_error:
             default: "[%{service_class_name}] Неправильный тип внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
-            for_hash:
-              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше внутреннего атрибута `%{internal_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
     outputs:
       undefined:
         for_fetch: "[%{service_class_name}] Неизвестный выходящий атрибут `%{output_name}`"
@@ -106,8 +110,10 @@ ru:
               default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` имеет значение `%{value}`, которое не кратно `%{option_value}`"
               blank: "[%{service_class_name}] Выходящий атрибут `%{output_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
               divided_by_0: "[%{service_class_name}] Выходящий атрибут `%{output_name}` имеет недопустимое значение `%{option_value}` в опции `%{option_name}`"
+            schema:
+              wrong_type: "[%{service_class_name}] Неправильный тип выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше выходящего атрибута `%{output_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_value: "[%{service_class_name}] Неправильное значение в хеше выходящего атрибута `%{output_name}`, для `%{key_name}` ожидалось значение с типом `%{expected_type}`, получено `%{given_type}`"
         type:
           default_error:
             default: "[%{service_class_name}] Неправильный тип выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
-            for_hash:
-              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше выходящего атрибута `%{output_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"

data/lib/servactory/configuration/setup.rb

@@ -72,6 +72,7 @@ module Servactory
         Set[
           Servactory::Maintenance::Attributes::OptionHelper.new(name: :optional, equivalent: { required: false }),
           Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
           Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end
@@ -79,6 +80,7 @@ module Servactory
       def default_internal_option_helpers
         Set[
           Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
           Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end
@@ -86,6 +88,7 @@ module Servactory
       def default_output_option_helpers
         Set[
           Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
           Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end

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

@@ -51,10 +51,6 @@ module Servactory
           input_value = @context.send(:servactory_service_warehouse).fetch_input(input.name)
           input_value = input.default if input.optional? && input_value.blank?
 
-          if input.hash_mode? && (tmp_schema = input.schema.fetch(:is)).present?
-            input_value = prepare_hash_values_inside(object: input_value, schema: tmp_schema)
-          end
-
           input_prepare = input.prepare.fetch(:in, nil)
           input_value = input_prepare.call(value: input_value) if input_prepare.present?
 
@@ -66,37 +62,6 @@ module Servactory
         end
         # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
 
-        def prepare_hash_values_inside(object:, schema:) # rubocop:disable Metrics/MethodLength
-          return object unless object.respond_to?(:fetch)
-
-          schema.to_h do |schema_key, schema_value|
-            attribute_type = schema_value.fetch(:type, String)
-
-            result =
-              if attribute_type == Hash
-                prepare_hash_values_inside(
-                  object: object.fetch(schema_key, {}),
-                  schema: schema_value.except(*RESERVED_ATTRIBUTES)
-                )
-              else
-                fetch_hash_values_from(
-                  value: object.fetch(schema_key, {}),
-                  schema_value:,
-                  attribute_required: schema_value.fetch(:required, true)
-                )
-              end
-
-            [schema_key, result]
-          end
-        end
-
-        def fetch_hash_values_from(value:, schema_value:, attribute_required:)
-          return value if attribute_required
-          return value if value.present?
-
-          schema_value.fetch(:default, nil)
-        end
-
         def raise_error_for(type, name)
           message_text = @context.send(:servactory_service_info).translate(
             "inputs.undefined.for_#{type}",

data/lib/servactory/inputs/dsl.rb

@@ -21,7 +21,6 @@ module Servactory
           collection_of_inputs << Input.new(
             name,
             *helpers,
-            hash_mode_class_names: config.hash_mode_class_names,
             option_helpers: config.input_option_helpers,
             **options
           )

data/lib/servactory/inputs/input.rb

@@ -38,13 +38,11 @@ module Servactory
         name,
         *helpers,
         as: nil,
-        hash_mode_class_names:,
         option_helpers:,
         **options
       )
         @name = name
         @internal_name = as.presence || name
-        @hash_mode_class_names = hash_mode_class_names
         @option_helpers = option_helpers
 
         register_options(helpers:, options:)
@@ -71,13 +69,11 @@ module Servactory
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
-          hash_mode_class_names: @hash_mode_class_names,
           options:,
           features: {
             required: true,
             types: true,
             default: true,
-            hash: true,
             must: true,
             prepare: true
           }

data/lib/servactory/internals/dsl.rb

@@ -20,7 +20,6 @@ module Servactory
           collection_of_internals << Internal.new(
             name,
             *helpers,
-            hash_mode_class_names: config.hash_mode_class_names,
             option_helpers: config.internal_option_helpers,
             **options
           )

data/lib/servactory/internals/internal.rb

@@ -29,12 +29,10 @@ module Servactory
       def initialize(
         name,
         *helpers,
-        hash_mode_class_names:,
         option_helpers:,
         **options
       )
         @name = name
-        @hash_mode_class_names = hash_mode_class_names
         @option_helpers = option_helpers
 
         register_options(helpers:, options:)
@@ -60,11 +58,9 @@ module Servactory
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
-          hash_mode_class_names: @hash_mode_class_names,
           options:,
           features: {
             types: true,
-            hash: true,
             must: true
           }
         )

data/lib/servactory/maintenance/attributes/option.rb

@@ -75,7 +75,6 @@ module Servactory
           )
         end
 
-        # rubocop:disable Metrics/MethodLength
         def prepare_advanced_for(
           body:,
           body_key:,
@@ -83,22 +82,17 @@ module Servactory
           body_fallback:
         )
           if body.is_a?(Hash)
-            if @name == :schema && body.fetch(body_key, nil).nil?
-              DEFAULT_BODY.call(key: body_key, body:)
-            else
-              message = body.fetch(:message, nil)
-
-              DEFAULT_BODY.call(
-                key: body_key,
-                body: body.fetch(body_key, message.present? ? body_value : body_fallback),
-                message:
-              )
-            end
+            message = body.fetch(:message, nil)
+
+            DEFAULT_BODY.call(
+              key: body_key,
+              body: body.fetch(body_key, message.present? ? body_value : body_fallback),
+              message:
+            )
           else
             DEFAULT_BODY.call(key: body_key, body:)
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def prepare_methods_for(attribute)
           attribute.instance_eval(define_methods_template) if define_methods_template.present?

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

@@ -10,7 +10,6 @@ module Servactory
             required
             default
             collection
-            hash
             must
             prepare
           ].freeze
@@ -19,7 +18,6 @@ module Servactory
             required: false,
             types: false,
             default: false,
-            hash: false,
             must: false,
             prepare: false
           }.freeze
@@ -30,9 +28,8 @@ module Servactory
             new(...).register
           end
 
-          def initialize(attribute:, hash_mode_class_names:, options:, features:)
+          def initialize(attribute:, options:, features:)
             @attribute = attribute
-            @hash_mode_class_names = hash_mode_class_names
             @options = options
             @features = DEFAULT_FEATURES.merge(features)
           end
@@ -46,7 +43,6 @@ module Servactory
             # Validation Class: Servactory::Maintenance::Attributes::Validations::Type
             register_types_option if @features.fetch(:types)
             register_default_option if @features.fetch(:default)
-            register_hash_option if @features.fetch(:hash)
 
             # Validation Class: Servactory::Maintenance::Attributes::Validations::Must
             register_must_option if @features.fetch(:must)
@@ -116,24 +112,6 @@ module Servactory
             )
           end
 
-          def register_hash_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
-              name: :schema,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Type,
-              define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
-                  name: :hash_mode?,
-                  content: ->(**) { @hash_mode_class_names.include?(@options.fetch(:type)) }
-                )
-              ],
-              need_for_checks: false,
-              body_key: :is,
-              body_fallback: {},
-              **@options
-            )
-          end
-
           def register_must_option # rubocop:disable Metrics/MethodLength
             collection << Servactory::Maintenance::Attributes::Option.new(
               name: :must,

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

@@ -8,7 +8,7 @@ module Servactory
           module_function
 
           def default_message
-            lambda do |service:, value:, code:, input: nil, internal: nil, output: nil, reason: nil|
+            lambda do |service:, value:, code:, input: nil, internal: nil, output: nil, reason: nil, **|
               attribute = Servactory::Utils.define_attribute_with(input:, internal:, output:)
 
               service.translate(

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

@@ -5,53 +5,18 @@ module Servactory
     module Attributes
       module Translator
         module Type
-          extend self
+          module_function
 
           def default_message
-            lambda do |service:, attribute:, key_name:, expected_type:, given_type:, **|
-              if attribute.hash_mode? && key_name.present?
-                for_hash_mode_with(service:, attribute:, key_name:,
-                                   expected_type:, given_type:)
-              else
-                for_others_with(service:, attribute:,
-                                expected_type:, given_type:)
-              end
-            end
-          end
-
-          private
-
-          def for_hash_mode_with(service:, attribute:, key_name:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength
-            hash_message = attribute.schema.fetch(:message)
-
-            if hash_message.is_a?(Proc)
-              hash_message.call(
-                **Servactory::Utils.fetch_hash_with_desired_attribute(attribute),
-                key_name:,
-                expected_type:,
-                given_type:
-              )
-            elsif hash_message.is_a?(String) && hash_message.present?
-              hash_message
-            else
+            lambda do |service:, attribute:, expected_type:, given_type:, **|
               service.translate(
-                "#{attribute.i18n_name}.validations.type.default_error.for_hash.wrong_element_type",
+                "#{attribute.i18n_name}.validations.type.default_error.default",
                 "#{attribute.system_name}_name": attribute.name,
-                key_name:,
                 expected_type:,
                 given_type:
               )
             end
           end
-
-          def for_others_with(service:, attribute:, expected_type:, given_type:)
-            service.translate(
-              "#{attribute.i18n_name}.validations.type.default_error.default",
-              "#{attribute.system_name}_name": attribute.name,
-              expected_type:,
-              given_type:
-            )
-          end
         end
       end
     end

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

@@ -28,11 +28,11 @@ module Servactory
 
           def check
             @check_options.each do |code, options|
-              message, reason = call_or_fetch_message_from(code, options)
+              message, reason, meta = call_or_fetch_message_from(code, options)
 
               next if message.blank?
 
-              add_error_with(message, code, reason)
+              add_error_with(message, code, reason, meta)
             end
 
             errors
@@ -43,14 +43,15 @@ module Servactory
           def call_or_fetch_message_from(code, options) # rubocop:disable Metrics/MethodLength
             check, message = options.values_at(:is, :message)
 
-            check_result, check_result_code =
+            check_result, check_result_code, meta =
               check.call(value: @value, **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute))
 
             return if check_result
 
             [
               message.presence || Servactory::Maintenance::Attributes::Translator::Must.default_message,
-              check_result_code
+              check_result_code,
+              meta
             ]
           rescue StandardError => e
             add_syntax_error_with(
@@ -62,14 +63,15 @@ module Servactory
 
           ########################################################################
 
-          def add_error_with(message, code, reason)
+          def add_error_with(message, code, reason, meta = {})
             add_error(
               message:,
               service: @context.send(:servactory_service_info),
               **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value,
               code:,
-              reason:
+              reason:,
+              meta:
             )
           end
 

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

@@ -16,32 +16,9 @@ module Servactory
           @error_callback = error_callback
         end
 
-        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          object_schema_validator = nil
-
-          if @attribute.hash_mode?
-            object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
-              object: @value,
-              schema: @attribute.schema
-            )
-
-            return if object_schema_validator.valid?
-          else
-            return if prepared_types.any? do |type| # rubocop:disable Style/IfInsideElse
-              @value.is_a?(type)
-            end
-          end
-
-          if (first_error = object_schema_validator&.errors&.first).present?
-            return @error_callback.call(
-              message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
-              service: @context.send(:servactory_service_info),
-              attribute: @attribute,
-              value: @value,
-              key_name: first_error.fetch(:key_name),
-              expected_type: first_error.fetch(:expected_type),
-              given_type: first_error.fetch(:given_type)
-            )
+        def validate! # rubocop:disable Metrics/MethodLength
+          return if prepared_types.any? do |type|
+            @value.is_a?(type)
           end
 
           @error_callback.call(

data/lib/servactory/outputs/dsl.rb

@@ -20,7 +20,6 @@ module Servactory
           collection_of_outputs << Output.new(
             name,
             *helpers,
-            hash_mode_class_names: config.hash_mode_class_names,
             option_helpers: config.output_option_helpers,
             **options
           )

data/lib/servactory/outputs/output.rb

@@ -29,12 +29,10 @@ module Servactory
       def initialize(
         name,
         *helpers,
-        hash_mode_class_names:,
         option_helpers:,
         **options
       )
         @name = name
-        @hash_mode_class_names = hash_mode_class_names
         @option_helpers = option_helpers
 
         register_options(helpers:, options:)
@@ -60,11 +58,9 @@ module Servactory
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
-          hash_mode_class_names: @hash_mode_class_names,
           options:,
           features: {
             types: true,
-            hash: true,
             must: true
           }
         )

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/consists_of_matcher.rb

@@ -6,17 +6,18 @@ module Servactory
       module Matchers
         module HaveServiceAttributeMatchers
           class ConsistsOfMatcher
+            OPTION_NAME = :consists_of
+            OPTION_BODY_KEY = :type
+
             attr_reader :missing_option
 
-            def initialize(described_class, attribute_type, attribute_name, option_types, consists_of_types,
-                           custom_message)
+            def initialize(described_class, attribute_type, attribute_name, option_types, consists_of_types)
               @described_class = described_class
               @attribute_type = attribute_type
               @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
               @attribute_name = attribute_name
               @option_types = option_types
               @consists_of_types = consists_of_types
-              @custom_message = custom_message
 
               @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
 
@@ -46,32 +47,14 @@ module Servactory
                         :attribute_name,
                         :option_types,
                         :consists_of_types,
-                        :custom_message,
                         :attribute_data
 
-            def submatcher_passes?(_subject) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-              attribute_consists_of = attribute_data.fetch(:consists_of)
-              attribute_consists_of_types = Array(attribute_consists_of.fetch(:type))
-              attribute_consists_of_message = attribute_consists_of.fetch(:message)
-
-              matched = attribute_consists_of_types.difference(consists_of_types).empty? &&
-                        consists_of_types.difference(attribute_consists_of_types).empty?
-
-              if custom_message.present? && !attribute_consists_of_message.nil?
-                if custom_message.is_a?(RSpec::Matchers::BuiltIn::BaseMatcher)
-                  RSpec::Expectations::ValueExpectationTarget
-                    .new(attribute_consists_of_message)
-                    .to(custom_message)
-                else
-                  matched &&= if attribute_consists_of_message.is_a?(Proc)
-                                attribute_consists_of_message.call.casecmp(custom_message).zero?
-                              else
-                                attribute_consists_of_message.casecmp(custom_message).zero?
-                              end
-                end
-              end
+            def submatcher_passes?(_subject)
+              attribute_consists_of = attribute_data.fetch(OPTION_NAME)
+              attribute_consists_of_types = Array(attribute_consists_of.fetch(OPTION_BODY_KEY))
 
-              matched
+              attribute_consists_of_types.difference(consists_of_types).empty? &&
+                consists_of_types.difference(attribute_consists_of_types).empty?
             end
 
             def build_missing_option