servactory 1.9.6 → 2.0.1

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,96 @@ 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,
+        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(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(options)
+        # Check Class: Servactory::Internals::Validations::Type
+        add_types_option_with(options)
+        add_collection_option_with(options)
+        add_hash_option_with(options)
       end
 
-      def required?
-        required
+      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 optional?
-        !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 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 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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class DefineConflict
+        attr_reader :content
+
+        def initialize(content:)
+          @content = content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class DefineMethod
+        attr_reader :name,
+                    :content
+
+        def initialize(name:, content:)
+          @name = name.to_sym
+          @content = content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class Option
+        DEFAULT_BODY = ->(key:, body:, message: nil) { { key => body, message: message } }
+
+        private_constant :DEFAULT_BODY
+
+        attr_reader :name,
+                    :validation_class,
+                    :define_methods,
+                    :define_conflicts,
+                    :need_for_checks,
+                    :body
+
+        # rubocop:disable Metrics/MethodLength
+        def initialize(
+          name:,
+          attribute:,
+          validation_class:,
+          need_for_checks:,
+          body_fallback:,
+          original_value: nil,
+          body_key: nil,
+          body_value: true,
+          define_methods: nil,
+          define_conflicts: nil,
+          with_advanced_mode: true,
+          **options
+        ) # do
+          @name = name.to_sym
+          @validation_class = validation_class
+          @define_methods = define_methods
+          @define_conflicts = define_conflicts
+          @need_for_checks = need_for_checks
+
+          @body = prepare_value_for(
+            original_value: original_value,
+            options: options,
+            body_key: body_key,
+            body_value: body_value,
+            body_fallback: body_fallback,
+            with_advanced_mode: with_advanced_mode
+          )
+
+          prepare_methods_for(attribute)
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def need_for_checks?
+          need_for_checks
+        end
+
+        private
+
+        def prepare_value_for(
+          original_value:,
+          options:,
+          body_key:,
+          body_value:,
+          body_fallback:,
+          with_advanced_mode:
+        )
+          return original_value if original_value.present?
+
+          return options.fetch(@name, body_fallback) unless with_advanced_mode
+
+          prepare_advanced_for(
+            body: options.fetch(@name, DEFAULT_BODY.call(key: body_key, body: body_fallback)),
+            body_key: body_key,
+            body_value: body_value,
+            body_fallback: body_fallback
+          )
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def prepare_advanced_for(
+          body:,
+          body_key:,
+          body_value:,
+          body_fallback:
+        )
+          if body.is_a?(Hash)
+            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?
+        end
+
+        def define_methods_template
+          return if @define_methods.blank?
+
+          @define_methods_template ||= @define_methods.map do |define_method|
+            <<-RUBY
+              def #{define_method.name}
+                #{define_method.content.call(option: @body)}
+              end
+            RUBY
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionHelper
+        attr_reader :name,
+                    :equivalent
+
+        def initialize(name:, equivalent:)
+          @name = name
+          @equivalent = equivalent
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionHelpersCollection
+        extend Forwardable
+        def_delegators :@collection, :<<, :find, :merge
+
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def find_by(name:)
+          find { |helper| helper.name == name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      class OptionsCollection
+        extend Forwardable
+        def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :find
+
+        def initialize(*)
+          @collection = Set.new
+        end
+
+        def names
+          map(&:name)
+        end
+
+        def validation_classes
+          filter { |option| option.validation_class.present? }.map(&:validation_class).uniq
+        end
+
+        def options_for_checks
+          filter(&:need_for_checks?).to_h do |option|
+            option_body = if option.body.is_a?(Hash)
+                            option.body.key?(:is) ? option.body.fetch(:is) : option.body
+                          else
+                            option.body
+                          end
+
+            [option.name, option_body]
+          end
+        end
+
+        def defined_conflict_code
+          flat_map do |option|
+            option.define_conflicts&.map do |define_input_conflict|
+              define_input_conflict.content.call
+            end
+          end.reject(&:blank?).first
+        end
+
+        def find_by(name:)
+          find { |option| option.name == name }
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/collection_mode/class_names_collection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module CollectionMode
+      class ClassNamesCollection
+        extend Forwardable
+        def_delegators :@collection, :include?
+
+        def initialize(collection)
+          @collection = collection
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/hash_mode/class_names_collection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module HashMode
+      class ClassNamesCollection
+        extend Forwardable
+        def_delegators :@collection, :include?
+
+        def initialize(collection)
+          @collection = collection
+        end
+      end
+    end
+  end
+end

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