servactory 2.0.0.rc2 → 2.0.0.rc4

data/lib/servactory/internals/validations/type.rb

@@ -4,65 +4,10 @@ module Servactory
   module Internals
     module Validations
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, internal:, value:, key_name:, expected_type:, given_type:| # rubocop:disable Metrics/BlockLength
-          if internal.collection_mode?
-            collection_message = internal.consists_of.fetch(:message)
-
-            if collection_message.is_a?(Proc)
-              collection_message.call(internal: internal, expected_type: expected_type)
-            elsif collection_message.is_a?(String) && collection_message.present?
-              collection_message
-            elsif value.is_a?(internal.types.fetch(0, Array))
-              I18n.t(
-                "servactory.internals.checks.type.default_error.for_collection.wrong_element_type",
-                service_class_name: service_class_name,
-                internal_name: internal.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            else
-              I18n.t(
-                "servactory.internals.checks.type.default_error.for_collection.wrong_type",
-                service_class_name: service_class_name,
-                internal_name: internal.name,
-                expected_type: internal.types.fetch(0, Array),
-                given_type: value.class.name
-              )
-            end
-          elsif internal.hash_mode? && key_name.present?
-            I18n.t(
-              "servactory.internals.checks.type.default_error.for_hash.wrong_element_type",
-              service_class_name: service_class_name,
-              internal_name: internal.name,
-              key_name: key_name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          else
-            I18n.t(
-              "servactory.internals.checks.type.default_error.default",
-              service_class_name: service_class_name,
-              internal_name: internal.name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          end
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
         def self.validate!(...)
-          return unless should_be_checked?
-
           new(...).validate!
         end
 
-        def self.should_be_checked?
-          true
-        end
-
-        ##########################################################################
-
         def initialize(context:, internal:, value:)
           super()
 
@@ -71,76 +16,13 @@ module Servactory
           @value = value
         end
 
-        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          object_schema_validator = nil
-
-          return if prepared_types.any? do |type|
-            if @internal.collection_mode?
-              @value.is_a?(@internal.types.fetch(0, Array)) &&
-              @value.respond_to?(:all?) && @value.all?(type)
-            elsif @internal.hash_mode?
-              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
-                object: @value,
-                schema: @internal.schema
-              )
-
-              object_schema_validator.valid?
-            else
-              @value.is_a?(type)
-            end
-          end
-
-          if (first_error = object_schema_validator&.errors&.first).present?
-            raise_default_object_error_with(first_error)
-          end
-
-          raise_default_error
-        end
-
-        private
-
-        def prepared_types
-          @prepared_types ||=
-            if @internal.collection_mode?
-              prepared_types_from(Array(@internal.consists_of.fetch(:type, [])))
-            else
-              prepared_types_from(@internal.types)
-            end
-        end
-
-        def prepared_types_from(types)
-          types.map do |type|
-            if type.is_a?(String)
-              Object.const_get(type)
-            else
-              type
-            end
-          end
-        end
-
-        ########################################################################
-
-        def raise_default_object_error_with(error)
-          raise_error_with(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            internal: @internal,
-            value: @value,
-            key_name: error.fetch(:name),
-            expected_type: error.fetch(:expected_type),
-            given_type: error.fetch(:given_type)
-          )
-        end
-
-        def raise_default_error
-          raise_error_with(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            internal: @internal,
+        def validate!
+          Servactory::Maintenance::Validations::Types.validate!(
+            context: @context,
+            attribute: @internal,
+            types: @internal.types,
             value: @value,
-            key_name: nil,
-            expected_type: prepared_types.join(", "),
-            given_type: @value.class.name
+            error_callback: ->(**args) { raise_error_with(**args) }
           )
         end
       end

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

@@ -75,6 +75,7 @@ module Servactory
           )
         end
 
+        # rubocop:disable Metrics/MethodLength
         def prepare_advanced_for(
           body:,
           body_key:,
@@ -82,17 +83,22 @@ module Servactory
           body_fallback:
         )
           if body.is_a?(Hash)
-            message = body.fetch(:message, nil)
-
-            DEFAULT_BODY.call(
-              key: body_key,
-              body: body.fetch(body_key, message.present? ? body_value : body_fallback),
-              message: message
-            )
+            if @name == :schema && body.fetch(body_key, nil).nil?
+              DEFAULT_BODY.call(key: body_key, body: 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: message
+              )
+            end
           else
             DEFAULT_BODY.call(key: body_key, body: 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/validations/collection.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class Collection
+        attr_reader :errors
+
+        def self.validate(...)
+          new(...).validate
+        end
+
+        def initialize(value:, types:, type:)
+          @value = value
+          @types = types
+          @type = type
+
+          @errors = []
+        end
+
+        def validate
+          unless @value.is_a?(prepared_type)
+            add_error(
+              expected_type: prepared_type.name,
+              given_type: @value.class.name
+            )
+
+            return self
+          end
+
+          validate_value!
+
+          self
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        private
+
+        def prepared_type
+          @prepared_type ||= @types.fetch(0, Array)
+        end
+
+        def validate_value!
+          @value.each do |value_item|
+            next if value_item.is_a?(@type)
+
+            add_error(
+              expected_type: @type,
+              given_type: value_item.class.name
+            )
+          end
+        end
+
+        def add_error(expected_type:, given_type:)
+          @errors << {
+            expected_type: expected_type,
+            given_type: given_type
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -15,31 +15,30 @@ module Servactory
 
         def initialize(object:, schema:)
           @object = object
-          @schema = schema
+          @schema = schema.fetch(:is)
 
-          @valid = false
           @errors = []
         end
 
         def validate
-          @valid = validate_for(object: @object, schema: @schema)
+          validate_for(object: @object, schema: @schema)
 
           self
         end
 
         def valid?
-          @valid
+          @errors.empty?
         end
 
         private
 
-        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength
+        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           unless object.respond_to?(:fetch)
-            add_error(name: root_schema_key, expected_type: Hash, given_type: object.class)
-            return false
+            add_error(key_name: root_schema_key, expected_type: Hash.name, given_type: object.class.name)
+            return
           end
 
-          schema.all? do |schema_key, schema_value|
+          schema.each do |schema_key, schema_value|
             attribute_type = schema_value.fetch(:type, String)
 
             if attribute_type == Hash
@@ -57,15 +56,13 @@ module Servactory
                 attribute_required: schema_value.fetch(:required, true)
               )
 
-              unless is_success
-                add_error(
-                  name: schema_key,
-                  expected_type: attribute_type,
-                  given_type: object.fetch(schema_key, nil).class
-                )
-              end
+              next if is_success
 
-              is_success
+              add_error(
+                key_name: schema_key,
+                expected_type: attribute_type,
+                given_type: object.fetch(schema_key, nil).class.name
+              )
             end
           end
         end
@@ -106,9 +103,9 @@ module Servactory
           value.fetch(:default, nil)
         end
 
-        def add_error(name:, expected_type:, given_type:)
+        def add_error(key_name:, expected_type:, given_type:)
           @errors << {
-            name: name,
+            key_name: key_name,
             expected_type: expected_type,
             given_type: given_type
           }

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

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class Types # rubocop:disable Metrics/ClassLength
+        DEFAULT_MESSAGE = lambda do | # rubocop:disable Metrics/BlockLength
+          service_class_name:,
+          attribute_system_name:,
+          attribute:,
+          value:,
+          key_name:,
+          expected_type:,
+          given_type:
+        | # do
+          if attribute.collection_mode?
+            collection_message = attribute.consists_of.fetch(:message)
+
+            if collection_message.is_a?(Proc)
+              collection_message.call(
+                "#{attribute_system_name}_name": attribute.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            elsif collection_message.is_a?(String) && collection_message.present?
+              collection_message
+            elsif value.is_a?(attribute.types.fetch(0, Array))
+              I18n.t(
+                "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_collection.wrong_element_type", # rubocop:disable Layout/LineLength
+                service_class_name: service_class_name,
+                "#{attribute_system_name}_name": attribute.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            else
+              I18n.t(
+                "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_collection.wrong_type", # rubocop:disable Layout/LineLength
+                service_class_name: service_class_name,
+                "#{attribute_system_name}_name": attribute.name,
+                expected_type: attribute.types.fetch(0, Array),
+                given_type: value.class.name
+              )
+            end
+          elsif attribute.hash_mode? && key_name.present?
+            hash_message = attribute.schema.fetch(:message)
+
+            if hash_message.is_a?(Proc)
+              hash_message.call(
+                "#{attribute_system_name}_name": attribute.name,
+                key_name: key_name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            elsif hash_message.is_a?(String) && hash_message.present?
+              hash_message
+            else
+              I18n.t(
+                "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.for_hash.wrong_element_type", # rubocop:disable Layout/LineLength
+                service_class_name: service_class_name,
+                "#{attribute_system_name}_name": attribute.name,
+                key_name: key_name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            end
+          else
+            I18n.t(
+              "servactory.#{attribute_system_name.to_s.pluralize}.checks.type.default_error.default",
+              service_class_name: service_class_name,
+              "#{attribute_system_name}_name": attribute.name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          end
+        end
+
+        private_constant :DEFAULT_MESSAGE
+
+        def self.validate!(...)
+          new(...).validate!
+        end
+
+        def initialize(context:, attribute:, types:, value:, error_callback:)
+          @context = context
+          @attribute = attribute
+          @types = types
+          @value = value
+          @error_callback = error_callback
+        end
+
+        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          collection_validator = nil
+          object_schema_validator = nil
+
+          return if prepared_types.any? do |type|
+            if @attribute.collection_mode?
+              collection_validator = Servactory::Maintenance::Validations::Collection.validate(
+                value: @value,
+                types: @attribute.types,
+                type: type
+              )
+
+              collection_validator.valid?
+            elsif @attribute.hash_mode?
+              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
+                object: @value,
+                schema: @attribute.schema
+              )
+
+              object_schema_validator.valid?
+            else
+              @value.is_a?(type)
+            end
+          end
+
+          if (first_error = collection_validator&.errors&.first).present?
+            return @error_callback.call(
+              message: DEFAULT_MESSAGE,
+              service_class_name: @context.class.name,
+              attribute_system_name: attribute_system_name,
+              attribute: @attribute,
+              value: @value,
+              key_name: nil,
+              expected_type: first_error.fetch(:expected_type),
+              given_type: first_error.fetch(:given_type)
+            )
+          end
+
+          if (first_error = object_schema_validator&.errors&.first).present?
+            return @error_callback.call(
+              message: DEFAULT_MESSAGE,
+              service_class_name: @context.class.name,
+              attribute_system_name: attribute_system_name,
+              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)
+            )
+          end
+
+          @error_callback.call(
+            message: DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            attribute_system_name: attribute_system_name,
+            attribute: @attribute,
+            value: @value,
+            key_name: nil,
+            expected_type: prepared_types.join(", "),
+            given_type: @value.class.name
+          )
+        end
+
+        private
+
+        def attribute_system_name
+          @attribute.class.name.demodulize.downcase.to_sym
+        end
+
+        def prepared_types
+          @prepared_types ||=
+            if @attribute.collection_mode?
+              prepared_types_from(Array(@attribute.consists_of.fetch(:type, [])))
+            else
+              prepared_types_from(@types)
+            end
+        end
+
+        def prepared_types_from(types)
+          types.map do |type|
+            if type.is_a?(String)
+              Object.const_get(type)
+            else
+              type
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/outputs/output.rb

@@ -37,7 +37,7 @@ module Servactory
         # Check Class: Servactory::Outputs::Validations::Type
         add_types_option_with(type)
         add_collection_option_with(type, options)
-        add_object_option_with(type, options)
+        add_hash_option_with(type, options)
       end
 
       def add_types_option_with(type)
@@ -71,7 +71,7 @@ module Servactory
         )
       end
 
-      def add_object_option_with(type, options) # rubocop:disable Metrics/MethodLength
+      def add_hash_option_with(type, options) # rubocop:disable Metrics/MethodLength
         collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :schema,
           attribute: self,
@@ -83,8 +83,8 @@ module Servactory
             )
           ],
           need_for_checks: false,
+          body_key: :is,
           body_fallback: {},
-          with_advanced_mode: false,
           **options
         )
       end

data/lib/servactory/outputs/validations/base.rb

@@ -6,7 +6,7 @@ module Servactory
       class Base
         protected
 
-        def raise_error_with(message, **attributes)
+        def raise_error_with(message:, **attributes)
           message = message.call(**attributes) if message.is_a?(Proc)
 
           raise @context.class.config.output_error_class.new(message: message)

data/lib/servactory/outputs/validations/type.rb

@@ -4,65 +4,10 @@ module Servactory
   module Outputs
     module Validations
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, output:, value:, key_name:, expected_type:, given_type:| # rubocop:disable Metrics/BlockLength
-          if output.collection_mode?
-            collection_message = output.consists_of.fetch(:message)
-
-            if collection_message.is_a?(Proc)
-              collection_message.call(output: output, expected_type: expected_type)
-            elsif collection_message.is_a?(String) && collection_message.present?
-              collection_message
-            elsif value.is_a?(output.types.fetch(0, Array))
-              I18n.t(
-                "servactory.outputs.checks.type.default_error.for_collection.wrong_element_type",
-                service_class_name: service_class_name,
-                output_name: output.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            else
-              I18n.t(
-                "servactory.outputs.checks.type.default_error.for_collection.wrong_type",
-                service_class_name: service_class_name,
-                output_name: output.name,
-                expected_type: output.types.fetch(0, Array),
-                given_type: value.class.name
-              )
-            end
-          elsif output.hash_mode? && key_name.present?
-            I18n.t(
-              "servactory.outputs.checks.type.default_error.for_hash.wrong_element_type",
-              service_class_name: service_class_name,
-              output_name: output.name,
-              key_name: key_name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          else
-            I18n.t(
-              "servactory.outputs.checks.type.default_error.default",
-              service_class_name: service_class_name,
-              output_name: output.name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          end
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
         def self.validate!(...)
-          return unless should_be_checked?
-
           new(...).validate!
         end
 
-        def self.should_be_checked?
-          true
-        end
-
-        ##########################################################################
-
         def initialize(context:, output:, value:)
           super()
 
@@ -71,76 +16,13 @@ module Servactory
           @value = value
         end
 
-        def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          object_schema_validator = nil
-
-          return if prepared_types.any? do |type|
-            if @output.collection_mode?
-              @value.is_a?(@output.types.fetch(0, Array)) &&
-              @value.respond_to?(:all?) && @value.all?(type)
-            elsif @output.hash_mode?
-              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
-                object: @value,
-                schema: @output.schema
-              )
-
-              object_schema_validator.valid?
-            else
-              @value.is_a?(type)
-            end
-          end
-
-          if (first_error = object_schema_validator&.errors&.first).present?
-            raise_default_object_error_with(first_error)
-          end
-
-          raise_default_error
-        end
-
-        private
-
-        def prepared_types
-          @prepared_types ||=
-            if @output.collection_mode?
-              prepared_types_from(Array(@output.consists_of.fetch(:type, [])))
-            else
-              prepared_types_from(@output.types)
-            end
-        end
-
-        def prepared_types_from(types)
-          types.map do |type|
-            if type.is_a?(String)
-              Object.const_get(type)
-            else
-              type
-            end
-          end
-        end
-
-        ########################################################################
-
-        def raise_default_object_error_with(error)
-          raise_error_with(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            output: @output,
-            value: @value,
-            key_name: error.fetch(:name),
-            expected_type: error.fetch(:expected_type),
-            given_type: error.fetch(:given_type)
-          )
-        end
-
-        def raise_default_error
-          raise_error_with(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            output: @output,
+        def validate!
+          Servactory::Maintenance::Validations::Types.validate!(
+            context: @context,
+            attribute: @output,
+            types: @output.types,
             value: @value,
-            key_name: nil,
-            expected_type: prepared_types.join(", "),
-            given_type: @value.class.name
+            error_callback: ->(**args) { raise_error_with(**args) }
           )
         end
       end