servactory 2.0.1 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a360afbf0c2646c3509ad3f37cb49e4a59453ded9f741a012965d962565285e4
-  data.tar.gz: 47a2bca86fc7622a7fa5e8a70bbb9cac4c179e3a43ee67ee050e6c5dd7b0cb21
+  metadata.gz: d4c3af571fde0fe1cc117e71ed04c7b13ab3d212f5524ad684382e905462fc8d
+  data.tar.gz: 95c2ad162f85d874eb250aa1db1104e8aae685e1f738ea9b37d94f19ebc6c92a
 SHA512:
-  metadata.gz: d6e1c489135e42759ee1bae986ed590aaf01164f8243a77b24a8a0b13d37056f4f5de3b86c1b741a94bbee8abe87656be6ad351818de32cc01a255af68d4db7e
-  data.tar.gz: 379633b8ddee7e378eafabacc9b97ced01375daa8612ce6b162c054674a6aac825093670602a92e2b03594c76f4f5dc22de9cbec25dcfa3770b0e73f102860fa
+  metadata.gz: 4a1385bd8a58e5931523772619812f53168593ab5135b2c9e92f6eda4ed90097a37bd7665e56669fca6e99303d406ad9ebe68684713f63ed0b8c530cf7f5bfb9
+  data.tar.gz: a720e57fece727a1374802a6b419c40eca107be60325a7282aa34559b9b6e519f8891f210c0c2185ea614c70b343b881803c24a5662dc9c863100f3a2cefdb22

data/lib/servactory/context/workspace/inputs.rb

@@ -40,7 +40,8 @@ module Servactory
 
         private
 
-        def getter_with(name:, &block) # rubocop:disable Metrics/MethodLength, Lint/UnusedMethodArgument, Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize,  Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
+        def getter_with(name:, &block)
           input_name = name.to_s.chomp("?").to_sym
           input = @collection_of_inputs.find_by(name: input_name)
 
@@ -61,6 +62,7 @@ module Servactory
             input.value
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize,  Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
 
         def prepare_hash_values_inside(object:, schema:) # rubocop:disable Metrics/MethodLength
           return object unless object.respond_to?(:fetch)

data/lib/servactory/inputs/input.rb

@@ -2,14 +2,12 @@
 
 module Servactory
   module Inputs
-    class Input # rubocop:disable Metrics/ClassLength
+    class Input
       attr_accessor :value
 
       attr_reader :name,
                   :internal_name,
-                  :collection_mode_class_names,
-                  :hash_mode_class_names,
-                  :option_helpers
+                  :collection_of_options
 
       # rubocop:disable Style/KeywordParametersOrder
       def initialize(
@@ -27,14 +25,12 @@ module Servactory
         @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(options)
+        register_options(helpers: helpers, options: options)
       end
       # rubocop:enable Style/KeywordParametersOrder
 
       def method_missing(name, *args, &block)
-        option = collection_of_options.find_by(name: name)
+        option = @collection_of_options.find_by(name: name)
 
         return super if option.nil?
 
@@ -42,14 +38,37 @@ module Servactory
       end
 
       def respond_to_missing?(name, *)
-        collection_of_options.names.include?(name) || super
+        @collection_of_options.names.include?(name) || super
+      end
+
+      def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
+        options = apply_helpers_for_options(helpers: helpers, options: options) if helpers.present?
+
+        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
+          attribute: self,
+          collection_mode_class_names: @collection_mode_class_names,
+          hash_mode_class_names: @hash_mode_class_names,
+          options: options,
+          features: {
+            required: true,
+            types: true,
+            default: true,
+            collection: true,
+            hash: true,
+            inclusion: true,
+            must: true,
+            prepare: true
+          }
+        )
+
+        @collection_of_options = options_registrar.collection
       end
 
       def apply_helpers_for_options(helpers:, options:)
         prepared_options = {}
 
         helpers.each do |helper|
-          found_helper = option_helpers.find_by(name: helper)
+          found_helper = @option_helpers.find_by(name: helper)
 
           next if found_helper.blank?
 
@@ -59,206 +78,12 @@ module Servactory
         options.merge(prepared_options)
       end
 
-      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(options)
-        add_default_option_with(options)
-        add_collection_option_with(options)
-        add_hash_option_with(options)
-
-        # Check Class: Servactory::Inputs::Validations::Inclusion
-        add_inclusion_option_with(options)
-
-        # Check Class: Servactory::Inputs::Validations::Must
-        add_must_option_with(options)
-
-        # Check Class: nil
-        add_prepare_option_with(options)
-      end
-
-      def add_required_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :required,
-          attribute: self,
-          validation_class: Servactory::Inputs::Validations::Required,
-          define_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :required?,
-              content: ->(option:) { Servactory::Utils.true?(option[:is]) }
-            ),
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :optional?,
-              content: ->(option:) { !Servactory::Utils.true?(option[:is]) }
-            )
-          ],
-          define_conflicts: [
-            Servactory::Maintenance::Attributes::DefineConflict.new(
-              content: -> { :required_vs_default if required? && default_value_present? }
-            )
-          ],
-          need_for_checks: true,
-          body_key: :is,
-          body_fallback: true,
-          **options
-        )
-      end
-
-      def add_types_option_with(options)
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :types,
-          attribute: self,
-          validation_class: Servactory::Inputs::Validations::Type,
-          original_value: Array(options.fetch(:type)),
-          need_for_checks: true,
-          body_fallback: nil,
-          with_advanced_mode: false
-        )
-      end
-
-      def add_default_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :default,
-          attribute: self,
-          validation_class: Servactory::Inputs::Validations::Type,
-          define_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :default_value_present?,
-              content: ->(option:) { !option.nil? }
-            )
-          ],
-          need_for_checks: true,
-          body_fallback: nil,
-          with_advanced_mode: false,
-          **options
-        )
-      end
-
-      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_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :hash_mode?,
-              content: ->(**) { hash_mode_class_names.include?(options.fetch(:type)) }
-            )
-          ],
-          define_conflicts: [
-            Servactory::Maintenance::Attributes::DefineConflict.new(
-              content: -> { :object_vs_inclusion if hash_mode? && inclusion_present? }
-            )
-          ],
-          need_for_checks: false,
-          body_key: :is,
-          body_fallback: {},
-          **options
-        )
-      end
-
-      def add_inclusion_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :inclusion,
-          attribute: self,
-          validation_class: Servactory::Inputs::Validations::Inclusion,
-          define_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :inclusion_present?,
-              content: ->(option:) { option[:in].is_a?(Array) && option[:in].present? }
-            )
-          ],
-          need_for_checks: true,
-          body_key: :in,
-          body_fallback: nil,
-          **options
-        )
-      end
-
-      def add_must_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :must,
-          attribute: self,
-          validation_class: Servactory::Inputs::Validations::Must,
-          define_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :must_present?,
-              content: ->(option:) { option.present? }
-            )
-          ],
-          need_for_checks: true,
-          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 << Servactory::Maintenance::Attributes::Option.new(
-          name: :prepare,
-          attribute: self,
-          validation_class: nil,
-          define_methods: [
-            Servactory::Maintenance::Attributes::DefineMethod.new(
-              name: :prepare_present?,
-              content: ->(option:) { option[:in].present? }
-            )
-          ],
-          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,
-          body_key: :in,
-          body_fallback: 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
+        @collection_of_options.options_for_checks
       end
 
       def conflict_code
-        collection_of_options.defined_conflict_code
+        @collection_of_options.defined_conflict_code
       end
 
       def with_conflicts?

data/lib/servactory/internals/internal.rb

@@ -3,9 +3,7 @@
 module Servactory
   module Internals
     class Internal
-      attr_reader :name,
-                  :collection_mode_class_names,
-                  :hash_mode_class_names
+      attr_reader :name
 
       def initialize(
         name,
@@ -17,11 +15,11 @@ module Servactory
         @collection_mode_class_names = collection_mode_class_names
         @hash_mode_class_names = hash_mode_class_names
 
-        add_basic_options_with(options)
+        register_options(options: options)
       end
 
       def method_missing(name, *args, &block)
-        option = collection_of_options.find_by(name: name)
+        option = @collection_of_options.find_by(name: name)
 
         return super if option.nil?
 
@@ -29,71 +27,27 @@ module Servactory
       end
 
       def respond_to_missing?(name, *)
-        collection_of_options.names.include?(name) || super
+        @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 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 add_collection_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :consists_of,
+      def register_options(options:) # rubocop:disable Metrics/MethodLength
+        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           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
+          collection_mode_class_names: @collection_mode_class_names,
+          hash_mode_class_names: @hash_mode_class_names,
+          options: options,
+          features: {
+            types: true,
+            collection: true,
+            hash: true
+          }
         )
-      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
+        @collection_of_options = options_registrar.collection
       end
 
       def options_for_checks
-        collection_of_options.options_for_checks
+        @collection_of_options.options_for_checks
       end
     end
   end

data/lib/servactory/maintenance/attributes/options/registrar.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      module Options
+        class Registrar # rubocop:disable Metrics/ClassLength
+          DEFAULT_FEATURES = {
+            required: false,
+            types: false,
+            default: false,
+            collection: false,
+            hash: false,
+            inclusion: false,
+            must: false,
+            prepare: false
+          }.freeze
+
+          private_constant :DEFAULT_FEATURES
+
+          def self.register(...)
+            new(...).register
+          end
+
+          def initialize(attribute:, collection_mode_class_names:, hash_mode_class_names:, options:, features:)
+            @attribute = attribute
+            @collection_mode_class_names = collection_mode_class_names
+            @hash_mode_class_names = hash_mode_class_names
+            @options = options
+            @features = DEFAULT_FEATURES.merge(features)
+          end
+
+          ########################################################################
+
+          def register # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            # Check Class: Servactory::Inputs::Validations::Required
+            register_required_option if @features.fetch(:required)
+
+            # Check Class: Servactory::Inputs::Validations::Type
+            register_types_option if @features.fetch(:types)
+            register_default_option if @features.fetch(:default)
+            register_collection_option if @features.fetch(:collection)
+            register_hash_option if @features.fetch(:hash)
+
+            # Check Class: Servactory::Inputs::Validations::Inclusion
+            register_inclusion_option if @features.fetch(:inclusion)
+
+            # Check Class: Servactory::Inputs::Validations::Must
+            register_must_option if @features.fetch(:must)
+
+            # Check Class: nil
+            register_prepare_option if @features.fetch(:prepare)
+
+            self
+          end
+
+          ########################################################################
+
+          def register_required_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :required,
+              attribute: @attribute,
+              validation_class: Servactory::Inputs::Validations::Required,
+              define_methods: [
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :required?,
+                  content: ->(option:) { Servactory::Utils.true?(option[:is]) }
+                ),
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :optional?,
+                  content: ->(option:) { !Servactory::Utils.true?(option[:is]) }
+                )
+              ],
+              define_conflicts: [
+                Servactory::Maintenance::Attributes::DefineConflict.new(
+                  content: -> { :required_vs_default if @attribute.required? && @attribute.default_value_present? }
+                )
+              ],
+              need_for_checks: true,
+              body_key: :is,
+              body_fallback: true,
+              **@options
+            )
+          end
+
+          def register_types_option
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :types,
+              attribute: @attribute,
+              validation_class: Servactory::Inputs::Validations::Type,
+              original_value: Array(@options.fetch(:type)),
+              need_for_checks: true,
+              body_fallback: nil,
+              with_advanced_mode: false
+            )
+          end
+
+          def register_default_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :default,
+              attribute: @attribute,
+              validation_class: Servactory::Inputs::Validations::Type,
+              define_methods: [
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :default_value_present?,
+                  content: ->(option:) { !option.nil? }
+                )
+              ],
+              need_for_checks: true,
+              body_fallback: nil,
+              with_advanced_mode: false,
+              **@options
+            )
+          end
+
+          def register_collection_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :consists_of,
+              attribute: @attribute,
+              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: lambda {
+                             :collection_vs_inclusion if @attribute.collection_mode? && @attribute.inclusion_present?
+                           }
+                )
+              ],
+              need_for_checks: false,
+              body_key: :type,
+              body_value: String,
+              body_fallback: String,
+              **@options
+            )
+          end
+
+          def register_hash_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :schema,
+              attribute: @attribute,
+              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)) }
+                )
+              ],
+              define_conflicts: [
+                Servactory::Maintenance::Attributes::DefineConflict.new(
+                  content: -> { :object_vs_inclusion if @attribute.hash_mode? && @attribute.inclusion_present? }
+                )
+              ],
+              need_for_checks: false,
+              body_key: :is,
+              body_fallback: {},
+              **@options
+            )
+          end
+
+          def register_inclusion_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :inclusion,
+              attribute: @attribute,
+              validation_class: Servactory::Inputs::Validations::Inclusion,
+              define_methods: [
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :inclusion_present?,
+                  content: ->(option:) { option[:in].is_a?(Array) && option[:in].present? }
+                )
+              ],
+              need_for_checks: true,
+              body_key: :in,
+              body_fallback: nil,
+              **@options
+            )
+          end
+
+          def register_must_option # rubocop:disable Metrics/MethodLength
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :must,
+              attribute: @attribute,
+              validation_class: Servactory::Inputs::Validations::Must,
+              define_methods: [
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :must_present?,
+                  content: ->(option:) { option.present? }
+                )
+              ],
+              need_for_checks: true,
+              body_key: :is,
+              body_fallback: nil,
+              with_advanced_mode: false,
+              **@options
+            )
+          end
+
+          def register_prepare_option # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name: :prepare,
+              attribute: @attribute,
+              validation_class: nil,
+              define_methods: [
+                Servactory::Maintenance::Attributes::DefineMethod.new(
+                  name: :prepare_present?,
+                  content: ->(option:) { option[:in].present? }
+                )
+              ],
+              define_conflicts: [
+                Servactory::Maintenance::Attributes::DefineConflict.new(
+                  content: -> { :prepare_vs_collection if @attribute.prepare_present? && @attribute.collection_mode? }
+                ),
+                Servactory::Maintenance::Attributes::DefineConflict.new(
+                  content: -> { :prepare_vs_inclusion if @attribute.prepare_present? && @attribute.inclusion_present? }
+                ),
+                Servactory::Maintenance::Attributes::DefineConflict.new(
+                  content: -> { :prepare_vs_must if @attribute.prepare_present? && @attribute.must_present? }
+                )
+              ],
+              need_for_checks: false,
+              body_key: :in,
+              body_fallback: false,
+              **@options
+            )
+          end
+
+          ########################################################################
+
+          def collection
+            @collection ||= Servactory::Maintenance::Attributes::OptionsCollection.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,10 +10,10 @@ module Servactory
           new(...).validate
         end
 
-        def initialize(value:, types:, type:)
-          @value = value
+        def initialize(attribute:, types:, value:)
+          @attribute = attribute
           @types = types
-          @type = type
+          @value = value
 
           @errors = []
         end
@@ -39,21 +39,41 @@ module Servactory
 
         private
 
+        def validate_value!
+          return if unnecessary_types.empty?
+
+          add_error(
+            expected_type: attribute_consists_of_types.join(", "),
+            given_type: unnecessary_types.join(", ")
+          )
+        end
+
+        ########################################################################
+
         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)
+        def attribute_consists_of_types
+          @attribute_consists_of_types ||= prepared_types_from(Array(@attribute.consists_of.fetch(:type, [])))
+        end
 
-            add_error(
-              expected_type: @type,
-              given_type: value_item.class.name
-            )
+        def unnecessary_types
+          @unnecessary_types ||= @value&.map(&:class)&.difference(attribute_consists_of_types).presence || []
+        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 add_error(expected_type:, given_type:)
           @errors << {
             expected_type: expected_type,

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

@@ -92,23 +92,23 @@ module Servactory
           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
-              )
+          if @attribute.collection_mode?
+            collection_validator = Servactory::Maintenance::Validations::Collection.validate(
+              attribute: @attribute,
+              types: @types,
+              value: @value
+            )
 
-              collection_validator.valid?
-            elsif @attribute.hash_mode?
-              object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
-                object: @value,
-                schema: @attribute.schema
-              )
+            return if 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
+            return if object_schema_validator.valid?
+          else
+            return if prepared_types.any? do |type| # rubocop:disable Style/IfInsideElse
               @value.is_a?(type)
             end
           end

data/lib/servactory/outputs/output.rb

@@ -3,9 +3,7 @@
 module Servactory
   module Outputs
     class Output
-      attr_reader :name,
-                  :collection_mode_class_names,
-                  :hash_mode_class_names
+      attr_reader :name
 
       def initialize(
         name,
@@ -17,11 +15,11 @@ module Servactory
         @collection_mode_class_names = collection_mode_class_names
         @hash_mode_class_names = hash_mode_class_names
 
-        add_basic_options_with(options)
+        register_options(options: options)
       end
 
       def method_missing(name, *args, &block)
-        option = collection_of_options.find_by(name: name)
+        option = @collection_of_options.find_by(name: name)
 
         return super if option.nil?
 
@@ -29,71 +27,27 @@ module Servactory
       end
 
       def respond_to_missing?(name, *)
-        collection_of_options.names.include?(name) || super
+        @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 add_collection_option_with(options) # rubocop:disable Metrics/MethodLength
-        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
-          name: :consists_of,
+      def register_options(options:) # rubocop:disable Metrics/MethodLength
+        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           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
+          collection_mode_class_names: @collection_mode_class_names,
+          hash_mode_class_names: @hash_mode_class_names,
+          options: options,
+          features: {
+            types: true,
+            collection: true,
+            hash: true
+          }
         )
-      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
+        @collection_of_options = options_registrar.collection
       end
 
       def options_for_checks
-        collection_of_options.options_for_checks
+        @collection_of_options.options_for_checks
       end
     end
   end

data/lib/servactory/version.rb

@@ -4,7 +4,7 @@ module Servactory
   module VERSION
     MAJOR = 2
     MINOR = 0
-    PATCH = 1
+    PATCH = 3
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.3
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-05 00:00:00.000000000 Z
+date: 2023-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -277,6 +277,7 @@ files:
 - lib/servactory/maintenance/attributes/option.rb
 - lib/servactory/maintenance/attributes/option_helper.rb
 - lib/servactory/maintenance/attributes/option_helpers_collection.rb
+- lib/servactory/maintenance/attributes/options/registrar.rb
 - lib/servactory/maintenance/attributes/options_collection.rb
 - lib/servactory/maintenance/collection_mode/class_names_collection.rb
 - lib/servactory/maintenance/hash_mode/class_names_collection.rb