servactory 2.12.0.rc1 → 2.12.0.rc3

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/option_helper.rb

@@ -5,11 +5,17 @@ module Servactory
     module Attributes
       class OptionHelper
         attr_reader :name,
-                    :equivalent
+                    :equivalent,
+                    :meta
 
-        def initialize(name:, equivalent:)
+        def initialize(name:, equivalent:, meta: {})
           @name = name
           @equivalent = equivalent
+          @meta = meta
+        end
+
+        def dynamic_option?
+          meta[:type] == :dynamic_option
         end
       end
     end

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

@@ -10,8 +10,6 @@ module Servactory
             required
             default
             collection
-            hash
-            inclusion
             must
             prepare
           ].freeze
@@ -20,8 +18,6 @@ module Servactory
             required: false,
             types: false,
             default: false,
-            hash: false,
-            inclusion: false,
             must: false,
             prepare: false
           }.freeze
@@ -32,26 +28,21 @@ 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
 
           ########################################################################
 
-          def register # rubocop:disable Metrics/CyclomaticComplexity
+          def register
             # Validation Class: Servactory::Inputs::Validations::Required
             register_required_option if @features.fetch(:required)
 
             # 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::Inclusion
-            register_inclusion_option if @features.fetch(:inclusion)
 
             # Validation Class: Servactory::Maintenance::Attributes::Validations::Must
             register_must_option if @features.fetch(:must)
@@ -121,47 +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)) }
-                )
-              ],
-              define_conflicts: [
-                Servactory::Maintenance::Attributes::DefineConflict.new(
-                  content: -> { :object_vs_inclusion if @attribute.hash_mode? && @attribute.inclusion_present? }
-                )
-              ],
-              need_for_checks: false,
-              body_key: :is,
-              body_fallback: {},
-              **@options
-            )
-          end
-
-          def register_inclusion_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
-              name: :inclusion,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Inclusion,
-              define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
-                  name: :inclusion_present?,
-                  content: ->(option:) { option[:in].is_a?(Array) && option[:in].present? }
-                )
-              ],
-              need_for_checks: true,
-              body_key: :in,
-              body_fallback: nil,
-              **@options
-            )
-          end
-
           def register_must_option # rubocop:disable Metrics/MethodLength
             collection << Servactory::Maintenance::Attributes::Option.new(
               name: :must,
@@ -192,11 +142,6 @@ module Servactory
                   content: ->(option:) { option[:in].present? }
                 )
               ],
-              define_conflicts: [
-                Servactory::Maintenance::Attributes::DefineConflict.new(
-                  content: -> { :prepare_vs_inclusion if @attribute.prepare_present? && @attribute.inclusion_present? }
-                )
-              ],
               need_for_checks: false,
               body_key: :in,
               body_fallback: false,

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

@@ -6,12 +6,12 @@ module Servactory
       class Actor
         attr_reader :name,
                     :types,
-                    :inclusion
+                    :options
 
         def initialize(output)
           @name = output.name
           @types = output.types
-          @inclusion = output.inclusion.slice(:in) if output.inclusion_present?
+          @options = output.options
 
           define_singleton_method(:system_name) { output.system_name }
           define_singleton_method(:i18n_name) { output.i18n_name }
@@ -23,17 +23,16 @@ module Servactory
       end
 
       attr_reader :name,
-                  :collection_of_options
+                  :collection_of_options,
+                  :options
 
       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:)
@@ -59,16 +58,14 @@ 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,
-            inclusion: true,
             must: true
           }
         )
 
+        @options = options
         @collection_of_options = options_registrar.collection
       end
 

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,20 +47,14 @@ module Servactory
                         :attribute_name,
                         :option_types,
                         :consists_of_types,
-                        :custom_message,
                         :attribute_data
 
             def submatcher_passes?(_subject)
-              attribute_must = attribute_data.fetch(:must)
-
-              attribute_must_keys = attribute_must.keys
-
-              expected_keys = %i[consists_of]
-
-              attribute_must_keys = attribute_must_keys.select { |key| expected_keys.include?(key) }
+              attribute_consists_of = attribute_data.fetch(OPTION_NAME)
+              attribute_consists_of_types = Array(attribute_consists_of.fetch(OPTION_BODY_KEY))
 
-              attribute_must_keys.difference(expected_keys).empty? &&
-                expected_keys.difference(attribute_must_keys).empty?
+              attribute_consists_of_types.difference(consists_of_types).empty? &&
+                consists_of_types.difference(attribute_consists_of_types).empty?
             end
 
             def build_missing_option

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

@@ -6,6 +6,9 @@ module Servactory
       module Matchers
         module HaveServiceAttributeMatchers
           class InclusionMatcher
+            OPTION_NAME = :inclusion
+            OPTION_BODY_KEY = :in
+
             attr_reader :missing_option
 
             def initialize(described_class, attribute_type, attribute_name, values)
@@ -44,16 +47,16 @@ module Servactory
                         :attribute_data
 
             def submatcher_passes?(_subject)
-              attribute_inclusion = attribute_data.fetch(:inclusion)
-              attribute_inclusion_in = attribute_inclusion.fetch(:in)
+              attribute_inclusion = attribute_data.fetch(OPTION_NAME)
+              attribute_inclusion_in = attribute_inclusion.fetch(OPTION_BODY_KEY)
 
               attribute_inclusion_in.difference(values).empty? &&
                 values.difference(attribute_inclusion_in).empty?
             end
 
             def build_missing_option
-              attribute_inclusion = attribute_data.fetch(:inclusion)
-              attribute_inclusion_in = attribute_inclusion.fetch(:in)
+              attribute_inclusion = attribute_data.fetch(OPTION_NAME)
+              attribute_inclusion_in = attribute_inclusion.fetch(OPTION_BODY_KEY)
 
               <<~MESSAGE
                 should include the expected values

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class MessageMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, submatcher, custom_message)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @custom_message = custom_message
+
+              attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              attribute_schema = attribute_data.fetch(submatcher.class::OPTION_NAME)
+              @attribute_schema_is = attribute_schema.fetch(submatcher.class::OPTION_BODY_KEY)
+              @attribute_schema_message = attribute_schema.fetch(:message)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "message: "
+              result + attribute_schema_message
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :option_types,
+                        :custom_message,
+                        :attribute_schema_is,
+                        :attribute_schema_message
+
+            def submatcher_passes?(_subject)
+              schema_message_equal?
+            end
+
+            def schema_message_equal? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              @schema_message_equal ||=
+                if custom_message.present? && !attribute_schema_message.nil?
+                  if custom_message.is_a?(RSpec::Matchers::BuiltIn::BaseMatcher)
+                    RSpec::Expectations::ValueExpectationTarget
+                      .new(attribute_schema_message)
+                      .to(custom_message)
+
+                    true
+                  elsif attribute_schema_message.is_a?(Proc)
+                    attribute_schema_message.call.casecmp(custom_message).zero?
+                  else
+                    attribute_schema_message.casecmp(custom_message).zero?
+                  end
+                else
+                  true
+                end
+            end
+
+            def build_missing_option
+              unless schema_message_equal? # rubocop:disable Style/GuardClause
+                <<~MESSAGE
+                  should return expected message in case of problem:
+
+                    expected #{attribute_schema_message.inspect}
+                         got #{custom_message.inspect}
+                MESSAGE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,12 @@ module Servactory
               # NOTE: Even though the dynamic option `consists_of` is a `must`, here we are testing explicit `must`.
               attribute_must_keys.delete(:consists_of)
 
+              # NOTE: Even though the dynamic option `schema` is a `must`, here we are testing explicit `must`.
+              attribute_must_keys.delete(:schema)
+
+              # NOTE: Even though the dynamic option `inclusion` is a `must`, here we are testing explicit `must`.
+              attribute_must_keys.delete(:inclusion)
+
               attribute_must_keys.difference(must_names).empty? &&
                 must_names.difference(attribute_must_keys).empty?
             end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class SchemaMatcher
+            OPTION_NAME = :schema
+            OPTION_BODY_KEY = :is
+
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, option_types, schema_data) # rubocop:disable Metrics/MethodLength
+              @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
+              @schema_data = schema_data
+
+              attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              attribute_schema = attribute_data.fetch(OPTION_NAME)
+              @attribute_schema_is = attribute_schema.fetch(OPTION_BODY_KEY)
+              @attribute_schema_message = attribute_schema.fetch(:message)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "schema: "
+              result + schema_data
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :option_types,
+                        :schema_data,
+                        :attribute_schema_is,
+                        :attribute_schema_message
+
+            def submatcher_passes?(_subject)
+              schema_data_equal?
+            end
+
+            def schema_data_equal?
+              @schema_data_equal ||=
+                (
+                  schema_data.present? && schema_data == attribute_schema_is
+                ) || schema_data.blank?
+            end
+
+            def build_missing_option
+              return if schema_data_equal?
+
+              <<~MESSAGE
+                should be schema with corresponding template
+
+                  expected #{attribute_schema_is.inspect}
+                       got #{schema_data.inspect}
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end