servactory 1.9.5 → 2.0.0.rc2

data/lib/servactory/inputs/tools/distributor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Inputs
+    module Tools
+      class Distributor
+        def self.assign!(...)
+          new(...).assign!
+        end
+
+        def initialize(incoming_arguments, collection_of_inputs)
+          @incoming_arguments = incoming_arguments
+          @collection_of_inputs = collection_of_inputs
+        end
+
+        def assign!
+          @collection_of_inputs.map do |input|
+            input.value = @incoming_arguments.fetch(input.name, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/inputs/tools/rules.rb

@@ -4,8 +4,8 @@ module Servactory
   module Inputs
     module Tools
       class Rules
-        def self.validate!(...)
-          new(...).validate!
+        def self.check!(...)
+          new(...).check!
         end
 
         def initialize(context, collection_of_inputs)
@@ -13,7 +13,7 @@ module Servactory
           @collection_of_inputs = collection_of_inputs
         end
 
-        def validate!
+        def check!
           @collection_of_inputs.each do |input|
             check_for!(input)
           end

data/lib/servactory/inputs/tools/{find_unnecessary.rb → unnecessary.rb}

@@ -3,9 +3,9 @@
 module Servactory
   module Inputs
     module Tools
-      class FindUnnecessary
-        def self.validate!(...)
-          new(...).validate!
+      class Unnecessary
+        def self.find!(...)
+          new(...).find!
         end
 
         def initialize(context, incoming_arguments, collection_of_inputs)
@@ -14,7 +14,7 @@ module Servactory
           @collection_of_inputs = collection_of_inputs
         end
 
-        def validate!
+        def find!
           return if unnecessary_attributes.empty?
 
           message_text = I18n.t(

data/lib/servactory/inputs/tools/validation.rb

@@ -8,9 +8,8 @@ module Servactory
           new(...).validate!
         end
 
-        def initialize(context, incoming_arguments, collection_of_inputs)
+        def initialize(context, collection_of_inputs)
           @context = context
-          @incoming_arguments = incoming_arguments
           @collection_of_inputs = collection_of_inputs
         end
 
@@ -32,8 +31,8 @@ module Servactory
 
         def process_option(check_key, check_options, input:)
           validation_classes_from(input).each do |validation_class|
-            errors_from_checks = process_validation_classes(
-              validation_class,
+            errors_from_checks = process_validation_class(
+              validation_class: validation_class,
               input: input,
               check_key: check_key,
               check_options: check_options
@@ -43,8 +42,8 @@ module Servactory
           end
         end
 
-        def process_validation_classes(
-          validation_class,
+        def process_validation_class(
+          validation_class:,
           input:,
           check_key:,
           check_options:
@@ -52,7 +51,6 @@ module Servactory
           validation_class.check(
             context: @context,
             input: input,
-            value: @incoming_arguments.fetch(input.name, nil),
             check_key: check_key,
             check_options: check_options
           )

data/lib/servactory/inputs/validations/inclusion.rb

@@ -16,43 +16,48 @@ module Servactory
 
         private_constant :DEFAULT_MESSAGE
 
-        def self.check(context:, input:, value:, check_key:, **)
-          return unless should_be_checked_for?(input, value, check_key)
+        def self.check(context:, input:, check_key:, **)
+          return unless should_be_checked_for?(input, check_key)
 
-          new(context: context, input: input, value: value).check
+          new(context: context, input: input).check
         end
 
-        def self.should_be_checked_for?(input, value, check_key)
+        def self.should_be_checked_for?(input, check_key)
           check_key == :inclusion && (
             input.required? || (
               input.optional? && !input.default.nil?
             ) || (
-              input.optional? && !value.nil?
+              input.optional? && !input.value.nil?
             )
           )
         end
 
         ##########################################################################
 
-        def initialize(context:, input:, value:)
+        def initialize(context:, input:)
           super()
 
           @context = context
           @input = input
-          @value = value
         end
 
         def check
           inclusion_in, message = @input.inclusion.values_at(:in, :message)
 
           return if inclusion_in.nil?
-          return if inclusion_in.include?(@value)
+          return if inclusion_in.include?(@input.value)
 
+          add_error_with(message)
+        end
+
+        private
+
+        def add_error_with(message)
           add_error(
             message.presence || DEFAULT_MESSAGE,
             service_class_name: @context.class.name,
             input: @input,
-            value: @value
+            value: @input.value
           )
         end
       end

data/lib/servactory/inputs/validations/must.rb

@@ -27,10 +27,10 @@ module Servactory
 
         private_constant :DEFAULT_MESSAGE, :SYNTAX_ERROR_MESSAGE
 
-        def self.check(context:, input:, value:, check_key:, check_options:)
+        def self.check(context:, input:, check_key:, check_options:)
           return unless should_be_checked_for?(input, check_key)
 
-          new(context: context, input: input, value: value, check_options: check_options).check
+          new(context: context, input: input, check_options: check_options).check
         end
 
         def self.should_be_checked_for?(input, check_key)
@@ -39,28 +39,21 @@ module Servactory
 
         ##########################################################################
 
-        def initialize(context:, input:, value:, check_options:)
+        def initialize(context:, input:, check_options:)
           super()
 
           @context = context
           @input = input
-          @value = value
           @check_options = check_options
         end
 
-        def check # rubocop:disable Metrics/MethodLength
+        def check
           @check_options.each do |code, options|
             message = call_or_fetch_message_from(code, options)
 
             next if message.blank?
 
-            add_error(
-              message,
-              service_class_name: @context.class.name,
-              input: @input,
-              value: @value,
-              code: code
-            )
+            add_error_with(message, code)
           end
 
           errors
@@ -68,20 +61,36 @@ module Servactory
 
         private
 
-        def call_or_fetch_message_from(code, options) # rubocop:disable Metrics/MethodLength
+        def call_or_fetch_message_from(code, options)
           check, message = options.values_at(:is, :message)
 
-          return if check.call(value: @value)
+          return if check.call(value: @input.value)
 
           message.presence || DEFAULT_MESSAGE
         rescue StandardError => e
+          add_syntax_error_with(SYNTAX_ERROR_MESSAGE, code, e.message)
+        end
+
+        ########################################################################
+
+        def add_error_with(message, code)
           add_error(
-            SYNTAX_ERROR_MESSAGE,
+            message,
             service_class_name: @context.class.name,
             input: @input,
-            value: @value,
+            value: @input.value,
+            code: code
+          )
+        end
+
+        def add_syntax_error_with(message, code, exception_message)
+          add_error(
+            message,
+            service_class_name: @context.class.name,
+            input: @input,
+            value: @input.value,
             code: code,
-            exception_message: e.message
+            exception_message: exception_message
           )
         end
       end

data/lib/servactory/inputs/validations/required.rb

@@ -6,7 +6,7 @@ module Servactory
       class Required < Base
         DEFAULT_MESSAGE = lambda do |service_class_name:, input:, value:|
           i18n_key = "servactory.inputs.checks.required.default_error."
-          i18n_key += input.array? && value.present? ? "for_array" : "default"
+          i18n_key += input.collection_mode? && value.present? ? "for_collection" : "default"
 
           I18n.t(
             i18n_key,
@@ -17,10 +17,10 @@ module Servactory
 
         private_constant :DEFAULT_MESSAGE
 
-        def self.check(context:, input:, value:, check_key:, **)
+        def self.check(context:, input:, check_key:, **)
           return unless should_be_checked_for?(input, check_key)
 
-          new(context: context, input: input, value: value).check
+          new(context: context, input: input).check
         end
 
         def self.should_be_checked_for?(input, check_key)
@@ -29,28 +29,33 @@ module Servactory
 
         ##########################################################################
 
-        def initialize(context:, input:, value:)
+        def initialize(context:, input:)
           super()
 
           @context = context
           @input = input
-          @value = value
         end
 
-        def check # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          if @input.array? && Servactory::Utils.value_present?(@value)
-            return if @value.respond_to?(:all?) && @value.all?(&:present?)
-          elsif Servactory::Utils.value_present?(@value)
+        def check
+          if @input.collection_mode? && Servactory::Utils.value_present?(@input.value)
+            return if @input.value.respond_to?(:all?) && @input.value.all?(&:present?)
+          elsif Servactory::Utils.value_present?(@input.value)
             return
           end
 
           _, message = @input.required.values_at(:is, :message)
 
+          add_error_with(message)
+        end
+
+        private
+
+        def add_error_with(message)
           add_error(
             message.presence || DEFAULT_MESSAGE,
             service_class_name: @context.class.name,
             input: @input,
-            value: @value
+            value: @input.value
           )
         end
       end

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

@@ -3,24 +3,33 @@
 module Servactory
   module Inputs
     module Validations
-      class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, input:, expected_type:, given_type:|
-          if input.array?
-            array_message = input.array[:message]
-
-            if array_message.is_a?(Proc)
-              array_message.call(input: input, expected_type: expected_type)
-            elsif array_message.is_a?(String) && array_message.present?
-              array_message
+      class Type < Base # rubocop:disable Metrics/ClassLength
+        DEFAULT_MESSAGE = lambda do |service_class_name:, input:, key_name:, expected_type:, given_type:| # rubocop:disable Metrics/BlockLength
+          if input.collection_mode?
+            collection_message = input.consists_of.fetch(:message)
+
+            if collection_message.is_a?(Proc)
+              collection_message.call(input: input, expected_type: expected_type)
+            elsif collection_message.is_a?(String) && collection_message.present?
+              collection_message
             else
               I18n.t(
-                "servactory.inputs.checks.type.default_error.for_array",
+                "servactory.inputs.checks.type.default_error.for_collection",
                 service_class_name: service_class_name,
                 input_name: input.name,
                 expected_type: expected_type,
                 given_type: given_type
               )
             end
+          elsif input.hash_mode? && key_name.present?
+            I18n.t(
+              "servactory.inputs.checks.type.default_error.for_hash.wrong_element_type",
+              service_class_name: service_class_name,
+              input_name: input.name,
+              key_name: key_name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
           else
             I18n.t(
               "servactory.inputs.checks.type.default_error.default",
@@ -34,67 +43,109 @@ module Servactory
 
         private_constant :DEFAULT_MESSAGE
 
-        def self.check(context:, input:, value:, check_key:, check_options:)
-          return unless should_be_checked_for?(input, value, check_key)
+        def self.check(context:, input:, check_key:, check_options:)
+          return unless should_be_checked_for?(input, check_key)
 
-          new(context: context, input: input, value: value, types: check_options).check
+          new(context: context, input: input, types: check_options).check
         end
 
-        def self.should_be_checked_for?(input, value, check_key)
+        def self.should_be_checked_for?(input, check_key)
           check_key == :types && (
             input.required? || (
               input.optional? && !input.default.nil?
             ) || (
-              input.optional? && !value.nil?
+              input.optional? && !input.value.nil?
             )
           )
         end
 
         ##########################################################################
 
-        def initialize(context:, input:, value:, types:)
+        def initialize(context:, input:, types:)
           super()
 
           @context = context
           @input = input
-          @value = value
           @types = types
         end
 
-        def check # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def check # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          object_schema_validator = nil
+
           return if prepared_types.any? do |type|
-            if @input.array?
-              prepared_value.is_a?(::Array) &&
+            if @input.collection_mode?
+              prepared_value.is_a?(@types.fetch(0, Array)) &&
               prepared_value.respond_to?(:all?) && prepared_value.all?(type)
+            elsif @input.hash_mode?
+              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
+                object: prepared_value,
+                schema: @input.schema
+              )
+
+              object_schema_validator.valid?
             else
               prepared_value.is_a?(type)
             end
           end
 
-          add_error(
-            DEFAULT_MESSAGE,
-            service_class_name: @context.class.name,
-            input: @input,
-            expected_type: prepared_types.join(", "),
-            given_type: prepared_value.class.name
-          )
+          if (first_error = object_schema_validator&.errors&.first).present?
+            return add_default_object_error_with(first_error)
+          end
+
+          add_default_error
         end
 
         ########################################################################
 
         def prepared_types
           @prepared_types ||=
-            @types.map do |type|
-              if type.is_a?(String)
-                Object.const_get(type)
-              else
-                type
-              end
+            if @input.collection_mode?
+              prepared_types_from(Array(@input.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
 
         def prepared_value
-          @prepared_value ||= @input.optional? && !@input.default.nil? && @value.blank? ? @input.default : @value
+          @prepared_value ||= if @input.optional? && !@input.default.nil? && @input.value.blank?
+                                @input.default
+                              else
+                                @input.value
+                              end
+        end
+
+        private
+
+        def add_default_object_error_with(error)
+          add_error(
+            DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            input: @input,
+            key_name: error.fetch(:name),
+            expected_type: error.fetch(:expected_type),
+            given_type: error.fetch(:given_type)
+          )
+        end
+
+        def add_default_error
+          add_error(
+            DEFAULT_MESSAGE,
+            service_class_name: @context.class.name,
+            input: @input,
+            key_name: nil,
+            expected_type: prepared_types.join(", "),
+            given_type: prepared_value.class.name
+          )
         end
       end
     end

data/lib/servactory/inputs/workspace.rb

@@ -3,12 +3,15 @@
 module Servactory
   module Inputs
     module Workspace
+      private
+
       def call!(incoming_arguments:, collection_of_inputs:, **)
         super
 
-        Tools::FindUnnecessary.validate!(self, incoming_arguments, collection_of_inputs)
-        Tools::Rules.validate!(self, collection_of_inputs)
-        Servactory::Inputs::Tools::Validation.validate!(self, incoming_arguments, collection_of_inputs)
+        Tools::Unnecessary.find!(self, incoming_arguments, collection_of_inputs)
+        Tools::Distributor.assign!(incoming_arguments, collection_of_inputs)
+        Tools::Rules.check!(self, collection_of_inputs)
+        Tools::Validation.validate!(self, collection_of_inputs)
       end
     end
   end

data/lib/servactory/internals/dsl.rb

@@ -17,7 +17,12 @@ module Servactory
         private
 
         def internal(name, **options)
-          collection_of_internals << Internal.new(name, **options)
+          collection_of_internals << Internal.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_internals

data/lib/servactory/internals/internal.rb

@@ -4,29 +4,97 @@ module Servactory
   module Internals
     class Internal
       attr_reader :name,
-                  :types,
-                  :required
+                  :collection_mode_class_names,
+                  :hash_mode_class_names
 
-      def initialize(name, type:, **options)
+      def initialize(
+        name,
+        type:,
+        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)
+        add_basic_options_with(type: type, options: options)
       end
 
-      def options_for_checks
-        {
-          types: types,
-          required: required
-        }
+      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(type:, options:)
+        # Check Class: Servactory::Internals::Validations::Type
+        add_types_option_with(type)
+        add_collection_option_with(type, options)
+        add_object_option_with(type, options)
       end
 
-      def required?
-        required
+      def add_types_option_with(type)
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
+          name: :types,
+          attribute: self,
+          validation_class: Servactory::Internals::Validations::Type,
+          original_value: Array(type),
+          need_for_checks: true,
+          body_fallback: nil,
+          with_advanced_mode: false
+        )
       end
 
-      def optional?
-        !required
+      def add_collection_option_with(type, 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?(type) }
+            )
+          ],
+          need_for_checks: false,
+          body_key: :type,
+          body_value: String,
+          body_fallback: String,
+          **options
+        )
+      end
+
+      def add_object_option_with(type, 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?(type) }
+            )
+          ],
+          need_for_checks: false,
+          body_fallback: {},
+          with_advanced_mode: false,
+          **options
+        )
+      end
+
+      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