servactory 1.9.6 → 2.0.1

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Validations
+      class ObjectSchema
+        RESERVED_ATTRIBUTES = %i[type required default].freeze
+        private_constant :RESERVED_ATTRIBUTES
+
+        attr_reader :errors
+
+        def self.validate(...)
+          new(...).validate
+        end
+
+        def initialize(object:, schema:)
+          @object = object
+          @schema = schema.fetch(:is)
+
+          @errors = []
+        end
+
+        def validate
+          validate_for(object: @object, schema: @schema)
+
+          self
+        end
+
+        def valid?
+          @errors.empty?
+        end
+
+        private
+
+        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          unless object.respond_to?(:fetch)
+            add_error(key_name: root_schema_key, expected_type: Hash.name, given_type: object.class.name)
+            return
+          end
+
+          schema.each do |schema_key, schema_value|
+            attribute_type = schema_value.fetch(:type, String)
+
+            if attribute_type == Hash
+              validate_for(
+                object: object.fetch(schema_key, {}),
+                schema: schema_value.except(*RESERVED_ATTRIBUTES),
+                root_schema_key: schema_key
+              )
+            else
+              is_success = validate_with(
+                object: object,
+                schema_key: schema_key,
+                schema_value: schema_value,
+                attribute_type: attribute_type,
+                attribute_required: schema_value.fetch(:required, true)
+              )
+
+              next if is_success
+
+              add_error(
+                key_name: schema_key,
+                expected_type: attribute_type,
+                given_type: object.fetch(schema_key, nil).class.name
+              )
+            end
+          end
+        end
+
+        def validate_with(object:, schema_key:, schema_value:, attribute_type:, attribute_required:) # rubocop:disable Metrics/MethodLength
+          unless should_be_checked_for?(
+            object: object,
+            schema_key: schema_key,
+            schema_value: schema_value,
+            required: attribute_required
+          ) # do
+            return true
+          end
+
+          value = object.fetch(schema_key, nil)
+          prepared_value = prepare_value_from(schema_value: schema_value, value: value, required: attribute_required)
+
+          Array(attribute_type).any? { |type| prepared_value.is_a?(type) }
+        end
+
+        def should_be_checked_for?(object:, schema_key:, schema_value:, required:)
+          required || (
+            !required && !fetch_default_from(schema_value).nil?
+          ) || (
+            !required && !object.fetch(schema_key, nil).nil?
+          )
+        end
+
+        def prepare_value_from(schema_value:, value:, required:)
+          if !required && !fetch_default_from(schema_value).nil? && value.blank?
+            fetch_default_from(schema_value)
+          else
+            value
+          end
+        end
+
+        def fetch_default_from(value)
+          value.fetch(:default, nil)
+        end
+
+        def add_error(key_name:, expected_type:, given_type:)
+          @errors << {
+            key_name: key_name,
+            expected_type: expected_type,
+            given_type: given_type
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -17,7 +17,12 @@ module Servactory
         private
 
         def output(name, **options)
-          collection_of_outputs << Output.new(name, **options)
+          collection_of_outputs << Output.new(
+            name,
+            collection_mode_class_names: config.collection_mode_class_names,
+            hash_mode_class_names: config.hash_mode_class_names,
+            **options
+          )
         end
 
         def collection_of_outputs

data/lib/servactory/outputs/output.rb

@@ -4,36 +4,96 @@ module Servactory
   module Outputs
     class Output
       attr_reader :name,
-                  :types,
-                  :required,
-                  :default
+                  :collection_mode_class_names,
+                  :hash_mode_class_names
 
-      def initialize(name, type:, **options)
+      def initialize(
+        name,
+        collection_mode_class_names:,
+        hash_mode_class_names:,
+        **options
+      )
         @name = name
-        @types = Array(type)
+        @collection_mode_class_names = collection_mode_class_names
+        @hash_mode_class_names = hash_mode_class_names
 
-        @required = options.fetch(:required, true)
-        @default = required? ? nil : options.fetch(:default, nil)
+        add_basic_options_with(options)
       end
 
-      def options_for_checks
-        {
-          types: types,
-          required: required,
-          default: default
-        }
+      def method_missing(name, *args, &block)
+        option = collection_of_options.find_by(name: name)
+
+        return super if option.nil?
+
+        option.body
+      end
+
+      def respond_to_missing?(name, *)
+        collection_of_options.names.include?(name) || super
+      end
+
+      def add_basic_options_with(options)
+        # Check Class: Servactory::Outputs::Validations::Type
+        add_types_option_with(options)
+        add_collection_option_with(options)
+        add_hash_option_with(options)
+      end
+
+      def add_types_option_with(options)
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
+          name: :types,
+          attribute: self,
+          validation_class: Servactory::Internals::Validations::Type,
+          original_value: Array(options.fetch(:type)),
+          need_for_checks: true,
+          body_fallback: nil,
+          with_advanced_mode: false
+        )
       end
 
-      def required?
-        Servactory::Utils.true?(required)
+      def add_collection_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
+          name: :consists_of,
+          attribute: self,
+          validation_class: Servactory::Internals::Validations::Type,
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
+              name: :collection_mode?,
+              content: ->(**) { collection_mode_class_names.include?(options.fetch(:type)) }
+            )
+          ],
+          need_for_checks: false,
+          body_key: :type,
+          body_value: String,
+          body_fallback: String,
+          **options
+        )
       end
 
-      def optional?
-        !required?
+      def add_hash_option_with(options) # rubocop:disable Metrics/MethodLength
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
+          name: :schema,
+          attribute: self,
+          validation_class: Servactory::Inputs::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 default_value_present?
-        !default.nil?
+      def collection_of_options
+        @collection_of_options ||= Servactory::Maintenance::Attributes::OptionsCollection.new
+      end
+
+      def options_for_checks
+        collection_of_options.options_for_checks
       end
     end
   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,24 +4,10 @@ module Servactory
   module Outputs
     module Validations
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, output:, expected_type:, given_type:|
-          I18n.t(
-            "servactory.outputs.checks.type.default_error",
-            service_class_name: service_class_name,
-            output_name: output.name,
-            expected_type: expected_type,
-            given_type: given_type
-          )
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
         def self.validate!(...)
           new(...).validate!
         end
 
-        ##########################################################################
-
         def initialize(context:, output:, value:)
           super()
 
@@ -31,39 +17,14 @@ module Servactory
         end
 
         def validate!
-          return unless should_be_checked?
-
-          return if prepared_types.any? { |type| @value.is_a?(type) }
-
-          raise_error_with(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            output: @output,
-            expected_type: prepared_types.join(", "),
-            given_type: @value.class.name
+          Servactory::Maintenance::Validations::Types.validate!(
+            context: @context,
+            attribute: @output,
+            types: @output.types,
+            value: @value,
+            error_callback: ->(**args) { raise_error_with(**args) }
           )
         end
-
-        private
-
-        def should_be_checked?
-          @output.required? || (
-            @output.optional? && !@output.default.nil?
-          ) || (
-            @output.optional? && !@value.nil?
-          )
-        end
-
-        def prepared_types
-          @prepared_types ||=
-            Array(@output.types).map do |type|
-              if type.is_a?(String)
-                Object.const_get(type)
-              else
-                type
-              end
-            end
-        end
       end
     end
   end

data/lib/servactory/version.rb

@@ -2,10 +2,11 @@
 
 module Servactory
   module VERSION
-    MAJOR = 1
-    MINOR = 9
-    PATCH = 6
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 1
+    PRE = nil
 
-    STRING = [MAJOR, MINOR, PATCH].join(".")
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end
 end

data/lib/servactory.rb

@@ -2,7 +2,7 @@
 
 require "zeitwerk"
 
-require "active_support/core_ext/string"
+require "active_support/all"
 
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect(