servactory 1.9.6 → 2.0.1

data/lib/servactory/inputs/input.rb

@@ -3,12 +3,12 @@
 module Servactory
   module Inputs
     class Input # rubocop:disable Metrics/ClassLength
-      ARRAY_DEFAULT_VALUE = ->(is: false, message: nil) { { is: is, message: message } }
-
-      private_constant :ARRAY_DEFAULT_VALUE
+      attr_accessor :value
 
       attr_reader :name,
                   :internal_name,
+                  :collection_mode_class_names,
+                  :hash_mode_class_names,
                   :option_helpers
 
       # rubocop:disable Style/KeywordParametersOrder
@@ -16,17 +16,20 @@ module Servactory
         name,
         *helpers,
         as: nil,
-        type:,
+        collection_mode_class_names:,
+        hash_mode_class_names:,
         option_helpers:,
         **options
       )
         @name = name
         @internal_name = as.present? ? as : name
+        @collection_mode_class_names = collection_mode_class_names
+        @hash_mode_class_names = hash_mode_class_names
         @option_helpers = option_helpers
 
         options = apply_helpers_for_options(helpers: helpers, options: options) if helpers.present?
 
-        add_basic_options_with(type: type, options: options)
+        add_basic_options_with(options)
       end
       # rubocop:enable Style/KeywordParametersOrder
 
@@ -35,7 +38,7 @@ module Servactory
 
         return super if option.nil?
 
-        option.value
+        option.body
       end
 
       def respond_to_missing?(name, *)
@@ -56,14 +59,15 @@ module Servactory
         options.merge(prepared_options)
       end
 
-      def add_basic_options_with(type:, options:)
+      def add_basic_options_with(options)
         # Check Class: Servactory::Inputs::Validations::Required
         add_required_option_with(options)
 
         # Check Class: Servactory::Inputs::Validations::Type
-        add_types_option_with(type)
+        add_types_option_with(options)
         add_default_option_with(options)
-        add_array_option_with(options)
+        add_collection_option_with(options)
+        add_hash_option_with(options)
 
         # Check Class: Servactory::Inputs::Validations::Inclusion
         add_inclusion_option_with(options)
@@ -73,166 +77,180 @@ module Servactory
 
         # Check Class: nil
         add_prepare_option_with(options)
-        add_internal_option_with(options)
       end
 
       def add_required_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :required,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Required,
-          define_input_methods: [
-            DefineInputMethod.new(
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :required?,
-              content: ->(value:) { Servactory::Utils.true?(value[:is]) }
+              content: ->(option:) { Servactory::Utils.true?(option[:is]) }
             ),
-            DefineInputMethod.new(
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :optional?,
-              content: ->(value:) { !Servactory::Utils.true?(value[:is]) }
+              content: ->(option:) { !Servactory::Utils.true?(option[:is]) }
             )
           ],
-          define_input_conflicts: [
-            DefineInputConflict.new(content: -> { :required_vs_default if required? && default_value_present? })
+          define_conflicts: [
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :required_vs_default if required? && default_value_present? }
+            )
           ],
           need_for_checks: true,
-          value_key: :is,
-          value_fallback: true,
+          body_key: :is,
+          body_fallback: true,
           **options
         )
       end
 
-      def add_types_option_with(type)
-        collection_of_options << Option.new(
+      def add_types_option_with(options)
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :types,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Type,
-          original_value: Array(type),
+          original_value: Array(options.fetch(:type)),
           need_for_checks: true,
-          value_fallback: nil,
+          body_fallback: nil,
           with_advanced_mode: false
         )
       end
 
       def add_default_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :default,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Type,
-          define_input_methods: [
-            DefineInputMethod.new(
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :default_value_present?,
-              content: ->(value:) { !value.nil? }
+              content: ->(option:) { !option.nil? }
             )
           ],
           need_for_checks: true,
-          value_fallback: nil,
+          body_fallback: nil,
           with_advanced_mode: false,
           **options
         )
       end
 
-      def add_array_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
-          name: :array,
-          input: self,
+      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::Inputs::Validations::Type,
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
+              name: :collection_mode?,
+              content: ->(**) { collection_mode_class_names.include?(options.fetch(:type)) }
+            )
+          ],
+          define_conflicts: [
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :collection_vs_inclusion if collection_mode? && inclusion_present? }
+            )
+          ],
+          need_for_checks: false,
+          body_key: :type,
+          body_value: String,
+          body_fallback: String,
+          **options
+        )
+      end
+
+      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_input_methods: [
-            DefineInputMethod.new(
-              name: :array?,
-              content: ->(value:) { Servactory::Utils.true?(value[:is]) }
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
+              name: :hash_mode?,
+              content: ->(**) { hash_mode_class_names.include?(options.fetch(:type)) }
             )
           ],
-          define_input_conflicts: [
-            DefineInputConflict.new(content: -> { :array_vs_array if array? && types.include?(Array) }),
-            DefineInputConflict.new(content: -> { :array_vs_inclusion if array? && inclusion_present? })
+          define_conflicts: [
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :object_vs_inclusion if hash_mode? && inclusion_present? }
+            )
           ],
           need_for_checks: false,
-          value_key: :is,
-          value_fallback: false,
+          body_key: :is,
+          body_fallback: {},
           **options
         )
       end
 
       def add_inclusion_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :inclusion,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Inclusion,
-          define_input_methods: [
-            DefineInputMethod.new(
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :inclusion_present?,
-              content: ->(value:) { value[:in].is_a?(Array) && value[:in].present? }
+              content: ->(option:) { option[:in].is_a?(Array) && option[:in].present? }
             )
           ],
           need_for_checks: true,
-          value_key: :in,
-          value_fallback: nil,
+          body_key: :in,
+          body_fallback: nil,
           **options
         )
       end
 
       def add_must_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :must,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Must,
-          define_input_methods: [
-            DefineInputMethod.new(
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :must_present?,
-              content: ->(value:) { value.present? }
+              content: ->(option:) { option.present? }
             )
           ],
           need_for_checks: true,
-          value_key: :is,
-          value_fallback: nil,
+          body_key: :is,
+          body_fallback: nil,
           with_advanced_mode: false,
           **options
         )
       end
 
       def add_prepare_option_with(options) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-        collection_of_options << Option.new(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :prepare,
-          input: self,
+          attribute: self,
           validation_class: nil,
-          define_input_methods: [
-            DefineInputMethod.new(
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
               name: :prepare_present?,
-              content: ->(value:) { value[:in].present? }
+              content: ->(option:) { option[:in].present? }
             )
           ],
-          define_input_conflicts: [
-            DefineInputConflict.new(content: -> { :prepare_vs_array if prepare_present? && array? }),
-            DefineInputConflict.new(content: -> { :prepare_vs_inclusion if prepare_present? && inclusion_present? }),
-            DefineInputConflict.new(content: -> { :prepare_vs_must if prepare_present? && must_present? })
-          ],
-          need_for_checks: false,
-          value_key: :in,
-          value_fallback: false,
-          **options
-        )
-      end
-
-      def add_internal_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Option.new(
-          name: :internal,
-          input: self,
-          validation_class: nil,
-          define_input_methods: [
-            DefineInputMethod.new(
-              name: :internal?,
-              content: ->(value:) { Servactory::Utils.true?(value[:is]) }
+          define_conflicts: [
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :prepare_vs_collection if prepare_present? && collection_mode? }
+            ),
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :prepare_vs_inclusion if prepare_present? && inclusion_present? }
+            ),
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :prepare_vs_must if prepare_present? && must_present? }
             )
           ],
           need_for_checks: false,
-          value_key: :is,
-          value_fallback: false,
+          body_key: :in,
+          body_fallback: false,
           **options
         )
       end
 
       def collection_of_options
-        @collection_of_options ||= OptionsCollection.new
+        @collection_of_options ||= Servactory::Maintenance::Attributes::OptionsCollection.new
       end
 
       def options_for_checks

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