servactory 1.9.6 → 2.0.0.rc3

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

@@ -6,7 +6,7 @@ module Servactory
       class Base
         private
 
-        def add_error(message, **attributes)
+        def add_error(message:, **attributes)
           message = message.call(**attributes) if message.is_a?(Proc)
 
           errors << message

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,
+            message: 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: 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: 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,
+            message: 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

@@ -4,97 +4,47 @@ 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]
+        def self.check(context:, input:, check_key:, **)
+          return unless should_be_checked_for?(input, check_key)
 
-            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
-            else
-              I18n.t(
-                "servactory.inputs.checks.type.default_error.for_array",
-                service_class_name: service_class_name,
-                input_name: input.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            end
-          else
-            I18n.t(
-              "servactory.inputs.checks.type.default_error.default",
-              service_class_name: service_class_name,
-              input_name: input.name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          end
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
-        def self.check(context:, input:, value:, check_key:, check_options:)
-          return unless should_be_checked_for?(input, value, check_key)
-
-          new(context: context, input: input, value: value, types: check_options).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 == :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:)
           super()
 
           @context = context
           @input = input
-          @value = value
-          @types = types
         end
 
-        def check # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          return if prepared_types.any? do |type|
-            if @input.array?
-              prepared_value.is_a?(::Array) &&
-              prepared_value.respond_to?(:all?) && prepared_value.all?(type)
-            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
+        def check
+          Servactory::Maintenance::Validations::Types.validate!(
+            context: @context,
+            attribute: @input,
+            types: @input.types,
+            value: prepared_value,
+            error_callback: ->(**args) { add_error(**args) }
           )
         end
 
-        ########################################################################
-
-        def prepared_types
-          @prepared_types ||=
-            @types.map do |type|
-              if type.is_a?(String)
-                Object.const_get(type)
-              else
-                type
-              end
-            end
-        end
+        private
 
         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
       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

data/lib/servactory/internals/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.internal_error_class.new(message: message)

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

@@ -4,24 +4,10 @@ module Servactory
   module Internals
     module Validations
       class Type < Base
-        DEFAULT_MESSAGE = lambda do |service_class_name:, internal:, expected_type:, given_type:|
-          I18n.t(
-            "servactory.internals.checks.type.default_error",
-            service_class_name: service_class_name,
-            internal_name: internal.name,
-            expected_type: expected_type,
-            given_type: given_type
-          )
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
         def self.validate!(...)
           new(...).validate!
         end
 
-        ##########################################################################
-
         def initialize(context:, internal:, value:)
           super()
 
@@ -31,37 +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,
-            internal: @internal,
-            expected_type: prepared_types.join(", "),
-            given_type: @value.class.name
+          Servactory::Maintenance::Validations::Types.validate!(
+            context: @context,
+            attribute: @internal,
+            types: @internal.types,
+            value: @value,
+            error_callback: ->(**args) { raise_error_with(**args) }
           )
         end
-
-        private
-
-        def should_be_checked?
-          @internal.required? || (
-            @internal.optional? && !@value.nil?
-          )
-        end
-
-        def prepared_types
-          @prepared_types ||=
-            Array(@internal.types).map do |type|
-              if type.is_a?(String)
-                Object.const_get(type)
-              else
-                type
-              end
-            end
-        end
       end
     end
   end