servactory 1.9.7 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c3038f0a3117da46c743b1a0e9cfd08581b19f7f34bff7e34efd27b1b194461
-  data.tar.gz: 3f74d7bcc690787caf7ea703d385befeaabaec6fdbe5c956704df401fa1a3ce8
+  metadata.gz: 7138f6d9bc8c21740306eabe282daf762cefd3e0504c1a40761f7db5c2e904ab
+  data.tar.gz: '09dbc3c8168b68e0db456ba7f0e71242412d05c19fb78d45b25f2161b7b06202'
 SHA512:
-  metadata.gz: a29637047ca7ee7ccf7b085ff0b95b68c0e6f8007edd527e13b90eb6bddd316a4831cd382077ccb36d5a178bc80c802c59db1f0ae12cf265dc398115ab59ad33
-  data.tar.gz: 0eb1142cef9a086c29596da9ee4b6b7c237e79ffe1ef98df1f44fe30fb6f33ee3a13411ea7faa083fd9a7b58fca04d5b3a72d1b0c887c82953402ef1b4d25fdf
+  metadata.gz: 91f6501df9724f4f116dc03ee57863c7e732f77f8c97b9eae7e9ecf64e85fdb7e5f5c976dcf4c92337711566ea122283013ddc4e3d34b60dd970dc380cc3dd0f
+  data.tar.gz: bf86943b60422743c0b829cce81fc3f753315a5c129edb228a54a42170f352816c8a306cefd53a2c5199dedfd4801a3df10f7d34043d12f924f22db290fd9450

data/config/locales/en.yml

@@ -13,11 +13,13 @@ en:
         required:
           default_error:
             default: "[%{service_class_name}] Required input `%{input_name}` is missing"
-            for_array: "[%{service_class_name}] Required element in input array `%{input_name}` is missing"
+            for_collection: "[%{service_class_name}] Required element in input collection `%{input_name}` is missing"
         type:
           default_error:
             default: "[%{service_class_name}] Wrong type of input `%{input_name}`, expected `%{expected_type}`, got `%{given_type}`"
-            for_array: "[%{service_class_name}] Wrong type in input array `%{input_name}`, expected `%{expected_type}`"
+            for_collection: "[%{service_class_name}] Wrong type in input collection `%{input_name}`, expected `%{expected_type}`"
+            for_hash:
+              wrong_element_type: "[%{service_class_name}] Wrong type in input hash `%{input_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
       tools:
         find_unnecessary:
           error: "[%{service_class_name}] Unexpected attributes: `%{unnecessary_attributes}`"
@@ -29,14 +31,26 @@ en:
         setter: "[%{service_class_name}] Undefined internal attribute `%{internal_name}`"
       checks:
         type:
-          default_error: "[%{service_class_name}] Wrong type of internal attribute `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
+          default_error:
+            default: "[%{service_class_name}] Wrong type of internal attribute `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
+            for_collection:
+              wrong_type: "[%{service_class_name}] Wrong internal attribute collection type `%{internal_name}`, expected `%{expected_type}`, got `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Wrong element type in internal attribute collection `%{internal_name}`, expected `%{expected_type}`"
+            for_hash:
+              wrong_element_type: "[%{service_class_name}] Wrong type in internal attribute hash `%{internal_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
     outputs:
       undefined:
         getter: "[%{service_class_name}] Undefined output attribute `%{output_name}`"
         setter: "[%{service_class_name}] Undefined output attribute `%{output_name}`"
       checks:
         type:
-          default_error: "[%{service_class_name}] Wrong type of output attribute `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"
+          default_error:
+            default: "[%{service_class_name}] Wrong type of output attribute `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"
+            for_collection:
+              wrong_type: "[%{service_class_name}] Wrong output attribute collection type `%{output_name}`, expected `%{expected_type}`, got `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Wrong element type in output attribute collection `%{output_name}`, expected `%{expected_type}`"
+            for_hash:
+              wrong_element_type: "[%{service_class_name}] Wrong type in output attribute hash `%{output_name}`, expected `%{expected_type}` for `%{key_name}`, got `%{given_type}`"
     methods:
       call:
         not_used: Nothing to perform. Use `make` or create a `call` method.

data/config/locales/ru.yml

@@ -6,18 +6,21 @@ ru:
         setter: "[%{service_class_name}] Неизвестный входящий атрибут `%{input_name}`"
       checks:
         inclusion:
-          default_error: "[%{service_class_name}] Неверное значение в `%{input_name}`, должно быть одним из `%{input_inclusion}`"
+          default_error: "[%{service_class_name}] Неправильное значение в `%{input_name}`, должно быть одним из `%{input_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Инпут `%{input_name}` должен \"%{code}\""
           syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` инпута `%{input_name}`"
         required:
           default_error:
             default: "[%{service_class_name}] Обязательный инпут `%{input_name}` отсутствует"
-            for_array: "[%{service_class_name}] Обязательный элемент в инпуте-массиве `%{input_name}` отсутствует"
+            for_collection: "[%{service_class_name}] Обязательный элемент в коллекции инпута `%{input_name}` отсутствует"
         type:
           default_error:
-            default: "[%{service_class_name}] Неверный тип инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
-            for_array: "[%{service_class_name}] Неверный тип инпута-массива `%{input_name}`, ожидалось `%{expected_type}`"
+            default: "[%{service_class_name}] Неправильный тип инпута `%{input_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+            for_collection: "[%{service_class_name}] Неправильный тип в коллекции инпута `%{input_name}`, ожидалось `%{expected_type}`"
+            for_hash:
+              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше инпута `%{input_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
+
       tools:
         find_unnecessary:
           error: "[%{service_class_name}] Неожиданные атрибуты: `%{unnecessary_attributes}`"
@@ -29,14 +32,25 @@ ru:
         setter: "[%{service_class_name}] Неизвестный внутренний атрибут `%{internal_name}`"
       checks:
         type:
-          default_error: "[%{service_class_name}] Неверный тип внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+          default_error:
+            default: "[%{service_class_name}] Неправильный тип внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+            for_collection:
+              wrong_type: "[%{service_class_name}] Неправильный тип коллекции внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+              wrong_element_type: "[%{service_class_name}] Неправильный тип элемента в коллекции внутреннего атрибута `%{internal_name}`, ожидалось `%{expected_type}`"
+            for_hash:
+              wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше внутреннего атрибута `%{internal_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
     outputs:
       undefined:
         getter: "[%{service_class_name}] Неизвестный выходящий атрибут `%{output_name}`"
         setter: "[%{service_class_name}] Неизвестный выходящий атрибут `%{output_name}`"
       checks:
         type:
-          default_error: "[%{service_class_name}] Неверный тип выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+          default: "[%{service_class_name}] Неправильный тип выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+          for_collection:
+            wrong_type: "[%{service_class_name}] Неправильный тип коллекции выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`, получено `%{given_type}`"
+            wrong_element_type: "[%{service_class_name}] Неправильный тип элемента в коллекции выходящего атрибута `%{output_name}`, ожидалось `%{expected_type}`"
+          for_hash:
+            wrong_element_type: "[%{service_class_name}] Неправильный тип в хеше выходящего атрибута `%{output_name}`, для `%{key_name}` ожидалось `%{expected_type}`, получено `%{given_type}`"
     methods:
       call:
         not_used: Нечего исполнять. Используйте `make` или создайте метод `call`.

data/lib/servactory/configuration/dsl.rb

@@ -17,6 +17,8 @@ module Servactory
 
           child.config.failure_class = config.failure_class
 
+          child.config.collection_mode_class_names = config.collection_mode_class_names
+
           child.config.input_option_helpers = config.input_option_helpers
 
           child.config.aliases_for_make = config.aliases_for_make

data/lib/servactory/configuration/factory.rb

@@ -23,6 +23,14 @@ module Servactory
         @config.failure_class = failure_class
       end
 
+      def collection_mode_class_names(collection_mode_class_names)
+        @config.collection_mode_class_names.merge(collection_mode_class_names)
+      end
+
+      def hash_mode_class_names(hash_mode_class_names)
+        @config.collection_mode_class_names.merge(hash_mode_class_names)
+      end
+
       def input_option_helpers(input_option_helpers)
         @config.input_option_helpers.merge(input_option_helpers)
       end

data/lib/servactory/configuration/setup.rb

@@ -7,18 +7,27 @@ module Servactory
                     :internal_error_class,
                     :output_error_class,
                     :failure_class,
+                    :collection_mode_class_names,
+                    :hash_mode_class_names,
                     :input_option_helpers,
                     :aliases_for_make,
                     :shortcuts_for_make
 
-      def initialize
+      def initialize # rubocop:disable Metrics/MethodLength
         @input_error_class = Servactory::Errors::InputError
         @internal_error_class = Servactory::Errors::InternalError
         @output_error_class = Servactory::Errors::OutputError
 
         @failure_class = Servactory::Errors::Failure
 
-        @input_option_helpers = Servactory::Inputs::OptionHelpersCollection.new(default_input_option_helpers)
+        @collection_mode_class_names =
+          Servactory::Maintenance::CollectionMode::ClassNamesCollection.new(default_collection_mode_class_names)
+
+        @hash_mode_class_names =
+          Servactory::Maintenance::HashMode::ClassNamesCollection.new(default_hash_mode_class_names)
+
+        @input_option_helpers =
+          Servactory::Maintenance::Attributes::OptionHelpersCollection.new(default_input_option_helpers)
 
         @aliases_for_make = Servactory::Methods::AliasesForMake::Collection.new
         @shortcuts_for_make = Servactory::Methods::ShortcutsForMake::Collection.new
@@ -26,10 +35,17 @@ module Servactory
 
       private
 
+      def default_collection_mode_class_names
+        Set[Array, Set]
+      end
+
+      def default_hash_mode_class_names
+        Set[Hash]
+      end
+
       def default_input_option_helpers
         Set[
-          Servactory::Inputs::OptionHelper.new(name: :optional, equivalent: { required: false }),
-          Servactory::Inputs::OptionHelper.new(name: :as_array, equivalent: { array: true })
+          Servactory::Maintenance::Attributes::OptionHelper.new(name: :optional, equivalent: { required: false }),
         ]
       end
     end

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

@@ -4,9 +4,11 @@ module Servactory
   module Context
     module Workspace
       class Inputs
-        def initialize(context:, incoming_arguments:, collection_of_inputs:)
+        RESERVED_ATTRIBUTES = %i[type required default].freeze
+        private_constant :RESERVED_ATTRIBUTES
+
+        def initialize(context:, collection_of_inputs:)
           @context = context
-          @incoming_arguments = incoming_arguments
           @collection_of_inputs = collection_of_inputs
         end
 
@@ -44,19 +46,51 @@ module Servactory
 
           return yield if input.nil?
 
-          input_value = @incoming_arguments.fetch(input.name, nil)
-          input_value = input.default if input.optional? && input_value.blank?
+          input.value = input.default if input.optional? && input.value.blank?
+
+          input.value = prepare_object_values_inside(object: input.value, schema: input.schema) if input.hash_mode?
 
           input_prepare = input.prepare.fetch(:in, nil)
-          input_value = input_prepare.call(value: input_value) if input_prepare.present?
+          input.value = input_prepare.call(value: input.value) if input_prepare.present?
 
           if name.to_s.end_with?("?")
-            Servactory::Utils.query_attribute(input_value)
+            Servactory::Utils.query_attribute(input.value)
           else
-            input_value
+            input.value
           end
         end
 
+        def prepare_object_values_inside(object:, schema:) # rubocop:disable Metrics/MethodLength
+          return object unless object.respond_to?(:fetch)
+
+          schema.to_h do |schema_key, schema_value|
+            attribute_type = schema_value.fetch(:type, String)
+
+            result =
+              if attribute_type == Hash
+                prepare_object_values_inside(
+                  object: object.fetch(schema_key, {}),
+                  schema: schema_value.except(*RESERVED_ATTRIBUTES)
+                )
+              else
+                fetch_object_values_from(
+                  value: object.fetch(schema_key, {}),
+                  schema_value: schema_value,
+                  attribute_required: schema_value.fetch(:required, true)
+                )
+              end
+
+            [schema_key, result]
+          end
+        end
+
+        def fetch_object_values_from(value:, schema_value:, attribute_required:)
+          return value if attribute_required
+          return value if value.present?
+
+          schema_value.fetch(:default, nil)
+        end
+
         def raise_error_for(type, name)
           message_text = I18n.t(
             "servactory.inputs.undefined.#{type}",

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

@@ -40,7 +40,7 @@ module Servactory
         def setter_with(prepared_name:, value:, &block) # rubocop:disable Lint/UnusedMethodArgument
           return yield unless @collection_of_outputs.names.include?(prepared_name)
 
-          output = @collection_of_outputs.find_by(name: prepared_name) # ::Servactory::Outputs::Output
+          output = @collection_of_outputs.find_by(name: prepared_name)
 
           return yield if output.nil?
 

data/lib/servactory/context/workspace.rb

@@ -6,7 +6,6 @@ module Servactory
       def inputs
         @inputs ||= Inputs.new(
           context: self,
-          incoming_arguments: incoming_arguments,
           collection_of_inputs: collection_of_inputs
         )
       end

data/lib/servactory/dsl.rb

@@ -2,6 +2,8 @@
 
 module Servactory
   module DSL
+    @extensions = []
+
     def self.included(base)
       base.include(Configuration::DSL)
       base.include(Info::DSL)
@@ -9,7 +11,22 @@ module Servactory
       base.include(Inputs::DSL)
       base.include(Internals::DSL)
       base.include(Outputs::DSL)
+
+      extensions.each { |extension| base.include(extension) }
+
       base.include(Methods::DSL)
     end
+
+    def self.with_extensions(*extensions)
+      @extensions = extensions
+
+      self
+    end
+
+    def self.extensions
+      @extensions
+    end
+
+    private_class_method :extensions
   end
 end

data/lib/servactory/inputs/collection.rb

@@ -4,7 +4,7 @@ module Servactory
   module Inputs
     class Collection
       extend Forwardable
-      def_delegators :@collection, :<<, :filter, :each, :map, :to_h, :merge, :find
+      def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :to_h, :merge, :find
 
       def initialize(collection = Set.new)
         @collection = collection

data/lib/servactory/inputs/dsl.rb

@@ -21,6 +21,8 @@ module Servactory
           collection_of_inputs << Input.new(
             name,
             *helpers,
+            collection_mode_class_names: config.collection_mode_class_names,
+            hash_mode_class_names: config.hash_mode_class_names,
             option_helpers: config.input_option_helpers,
             **options
           )

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
@@ -17,11 +17,15 @@ module Servactory
         *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?
@@ -35,7 +39,7 @@ module Servactory
 
         return super if option.nil?
 
-        option.value
+        option.body
       end
 
       def respond_to_missing?(name, *)
@@ -63,7 +67,8 @@ module Servactory
         # Check Class: Servactory::Inputs::Validations::Type
         add_types_option_with(type)
         add_default_option_with(options)
-        add_array_option_with(options)
+        add_collection_option_with(type, options)
+        add_object_option_with(type, options)
 
         # Check Class: Servactory::Inputs::Validations::Inclusion
         add_inclusion_option_with(options)
@@ -73,166 +78,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(
+        collection_of_options << Servactory::Maintenance::Attributes::Option.new(
           name: :types,
-          input: self,
+          attribute: self,
           validation_class: Servactory::Inputs::Validations::Type,
           original_value: Array(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(type, 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_input_methods: [
-            DefineInputMethod.new(
-              name: :array?,
-              content: ->(value:) { Servactory::Utils.true?(value[:is]) }
+          define_methods: [
+            Servactory::Maintenance::Attributes::DefineMethod.new(
+              name: :collection_mode?,
+              content: ->(**) { collection_mode_class_names.include?(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: -> { :collection_vs_inclusion if collection_mode? && inclusion_present? }
+            )
           ],
           need_for_checks: false,
-          value_key: :is,
-          value_fallback: 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) }
+            )
+          ],
+          define_conflicts: [
+            Servactory::Maintenance::Attributes::DefineConflict.new(
+              content: -> { :object_vs_inclusion if hash_mode? && inclusion_present? }
+            )
+          ],
+          need_for_checks: false,
+          body_fallback: {},
+          with_advanced_mode: false,
           **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