servactory 2.11.0 → 2.12.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a14d75bf3c1035ecffff36644b509241bdea300d28b56aa91e15e933c9184cb1
-  data.tar.gz: 062d490213f603fa45571b4217f3a8f8a892e92fdfd348e6702b2c71246d9480
+  metadata.gz: 8d25dddc86ece8552d4644707ec8ed928d743287e7b6d8cac5b6651c2f4376b4
+  data.tar.gz: 75954babfecf8c47e89961b6a3795b66264d34c09a9362e6ea30891d2453b156
 SHA512:
-  metadata.gz: 95b646ef01984996b9a9607e2a01a6adb324e76d0b637a78f4de73105840a3c17af27b20ca2286805161f5eb134da3b9b616d8ec7de6b5fc86bcc7847e265bfc
-  data.tar.gz: 61e57e674dbd46d934da1cbbe63b8574cd890913ca9ae63082529e627140105d724ba3e1a761c73a081eac7cb94169752dfd424cd7b9a17c3629910937e8917e
+  metadata.gz: 3d5e14c6eed833a4e2181cbf68d87a69b869a7b98479402a26feb1b1ab2404cb5d74ec3e9cfa6a858a1b059980d3164bcf6c63c4faaddbf57925363a2cd3588b
+  data.tar.gz: cf7f8c2c6fd19d0f743e610a8de747f00fe0e885aa0c62ff392be27522a2d8d7dc88a8cbdd3916099ca4f21f8efcc5132d0ef3f995e37f8c5993bbca9dc207d6

data/config/locales/en.yml

@@ -12,8 +12,6 @@ en:
         for_fetch: "[%{service_class_name}] Undefined input attribute `%{input_name}`"
         for_assign: "[%{service_class_name}] Undefined input attribute `%{input_name}`"
       validations:
-        inclusion:
-          default_error: "[%{service_class_name}] Wrong value in `%{input_name}`, must be one of `%{input_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Input `%{input_name}` must \"%{code}\""
           syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{input_name}` input: %{exception_message}"
@@ -26,6 +24,8 @@ en:
               default: "[%{service_class_name}] Input `%{input_name}` does not match `%{format_name}` format"
               wrong_pattern: "[%{service_class_name}] Input `%{input_name}` does not match `%{format_name}` format"
               unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for input `%{input_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Wrong value in `%{input_name}`, must be one of `%{input_inclusion}`, got `%{value}`"
             min:
               default: "[%{service_class_name}] Input `%{input_name}` received value `%{value}`, which is less than `%{option_value}`"
             max:
@@ -52,8 +52,6 @@ en:
         for_fetch: "[%{service_class_name}] Undefined internal attribute `%{internal_name}`"
         for_assign: "[%{service_class_name}] Undefined internal attribute `%{internal_name}`"
       validations:
-        inclusion:
-          default_error: "[%{service_class_name}] Wrong value in `%{internal_name}`, must be one of `%{internal_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Internal attribute `%{internal_name}` must \"%{code}\""
           syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{internal_name}` internal attribute: %{exception_message}"
@@ -66,6 +64,8 @@ en:
               default: "[%{service_class_name}] Internal attribute `%{internal_name}` does not match `%{format_name}` format"
               wrong_pattern: "[%{service_class_name}] Internal attribute `%{internal_name}` does not match `%{format_name}` format"
               unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for internal attribute `%{internal_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Wrong value in `%{internal_name}`, must be one of `%{internal_inclusion}`, got `%{value}`"
             min:
               default: "[%{service_class_name}] Internal attribute `%{internal_name}` received value `%{value}`, which is less than `%{option_value}`"
             max:
@@ -84,8 +84,6 @@ en:
         for_fetch: "[%{service_class_name}] Undefined output attribute `%{output_name}`"
         for_assign: "[%{service_class_name}] Undefined output attribute `%{output_name}`"
       validations:
-        inclusion:
-          default_error: "[%{service_class_name}] Wrong value in `%{output_name}`, must be one of `%{output_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Output attribute `%{output_name}` must \"%{code}\""
           syntax_error: "[%{service_class_name}] Syntax error inside `%{code}` of `%{output_name}` output attribute: %{exception_message}"
@@ -98,6 +96,8 @@ en:
               default: "[%{service_class_name}] Output attribute `%{output_name}` does not match `%{format_name}` format"
               wrong_pattern: "[%{service_class_name}] Output attribute `%{output_name}` does not match `%{format_name}` format"
               unknown: "[%{service_class_name}] Unknown `%{format_name}` format specified for output attribute `%{output_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Wrong value in `%{output_name}`, must be one of `%{output_inclusion}`, got `%{value}`"
             min:
               default: "[%{service_class_name}] Output attribute `%{output_name}` received value `%{value}`, which is less than `%{option_value}`"
             max:

data/config/locales/ru.yml

@@ -12,8 +12,6 @@ ru:
         for_fetch: "[%{service_class_name}] Неизвестный входящий атрибут `%{input_name}`"
         for_assign: "[%{service_class_name}] Неизвестный входящий атрибут `%{input_name}`"
       validations:
-        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}`: %{exception_message}"
@@ -26,6 +24,8 @@ ru:
               default: "[%{service_class_name}] Инпут `%{input_name}` не соответствует формату `%{format_name}`"
               wrong_pattern: "[%{service_class_name}] Инпут `%{input_name}` не соответствует формату `%{format_name}`"
               unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у инпута `%{input_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Неправильное значение в `%{input_name}`, должно быть одним из `%{input_inclusion}`, получено `%{value}`"
             min:
               default: "[%{service_class_name}] Инпут `%{input_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
             max:
@@ -52,8 +52,6 @@ ru:
         for_fetch: "[%{service_class_name}] Неизвестный внутренний атрибут `%{internal_name}`"
         for_assign: "[%{service_class_name}] Неизвестный внутренний атрибут `%{internal_name}`"
       validations:
-        inclusion:
-          default_error: "[%{service_class_name}] Неправильное значение в `%{internal_name}`, должно быть одним из `%{internal_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` должен \"%{code}\""
           syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` внутреннего атрибута `%{internal_name}`: %{exception_message}"
@@ -66,6 +64,8 @@ ru:
               default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` не соответствует формату `%{format_name}`"
               wrong_pattern: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` не соответствует формату `%{format_name}`"
               unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у внутреннего атрибута `%{internal_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Неправильное значение в `%{internal_name}`, должно быть одним из `%{internal_inclusion}`, получено `%{value}`"
             min:
               default: "[%{service_class_name}] Внутренний атрибут `%{internal_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
             max:
@@ -84,8 +84,6 @@ ru:
         for_fetch: "[%{service_class_name}] Неизвестный выходящий атрибут `%{output_name}`"
         for_assign: "[%{service_class_name}] Неизвестный выходящий атрибут `%{output_name}`"
       validations:
-        inclusion:
-          default_error: "[%{service_class_name}] Неправильное значение в `%{output_name}`, должно быть одним из `%{output_inclusion}`"
         must:
           default_error: "[%{service_class_name}] Выходящий атрибут `%{output_name}` должен \"%{code}\""
           syntax_error: "[%{service_class_name}] Синтаксическая ошибка внутри `%{code}` выходящего атрибута `%{output_name}`: %{exception_message}"
@@ -98,6 +96,8 @@ ru:
               default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` не соответствует формату `%{format_name}`"
               wrong_pattern: "[%{service_class_name}] Выходящий атрибут `%{output_name}` не соответствует формату `%{format_name}`"
               unknown: "[%{service_class_name}] Указан неизвестный формат `%{format_name}` у выходящего атрибута `%{output_name}`"
+            inclusion:
+              default: "[%{service_class_name}] Неправильное значение в `%{output_name}`, должно быть одним из `%{output_inclusion}`, получено `%{value}`"
             min:
               default: "[%{service_class_name}] Выходящий атрибут `%{output_name}` получил значение `%{value}`, которое меньше `%{option_value}`"
             max:

data/lib/servactory/configuration/option_helpers/option_helpers_collection.rb

@@ -5,12 +5,16 @@ module Servactory
     module OptionHelpers
       class OptionHelpersCollection
         extend Forwardable
-        def_delegators :@collection, :<<, :find, :merge
+        def_delegators :@collection, :<<, :filter, :map, :find, :merge
 
         def initialize(collection = Set.new)
           @collection = collection
         end
 
+        def dynamic_options
+          OptionHelpersCollection.new(filter(&:dynamic_option?))
+        end
+
         def find_by(name:)
           find { |helper| helper.name == name }
         end

data/lib/servactory/configuration/setup.rb

@@ -71,19 +71,22 @@ module Servactory
       def default_input_option_helpers
         Set[
           Servactory::Maintenance::Attributes::OptionHelper.new(name: :optional, equivalent: { required: false }),
-          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:)
+          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end
 
       def default_internal_option_helpers
         Set[
-          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:)
+          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end
 
       def default_output_option_helpers
         Set[
-          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:)
+          Servactory::ToolKit::DynamicOptions::ConsistsOf.use(collection_mode_class_names:),
+          Servactory::ToolKit::DynamicOptions::Inclusion.use
         ]
       end
     end

data/lib/servactory/context/warehouse/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      class Base
+        def initialize(arguments = {})
+          @arguments = arguments
+        end
+
+        # def fetch!(name)
+        #   @arguments.fetch(name)
+        # end
+
+        def fetch(name, default_value)
+          @arguments.fetch(name, default_value)
+        end
+
+        def assign(key, value)
+          @arguments[key] = value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      class Inputs < Base
+        def initialize(context, arguments = {})
+          @context = context
+
+          super(arguments)
+        end
+
+        def names
+          @arguments.keys
+        end
+
+        def merge!(arguments)
+          @arguments.merge!(arguments)
+        end
+
+        ##########################################################################
+
+        def method_missing(name, *_args)
+          input_name = @context.class.config.predicate_methods_enabled? ? name.to_s.chomp("?").to_sym : name
+
+          input_value = @arguments.fetch(input_name) { raise_error_for(input_name) }
+
+          if name.to_s.end_with?("?") && @context.class.config.predicate_methods_enabled?
+            Servactory::Utils.query_attribute(input_value)
+          else
+            input_value
+          end
+        end
+
+        def respond_to_missing?(name, *)
+          @arguments.fetch(name) { raise_error_for(name) }
+        end
+
+        ##########################################################################
+
+        def raise_error_for(input_name)
+          message_text = @context.send(:servactory_service_info).translate(
+            "inputs.undefined.for_fetch",
+            input_name:
+          )
+
+          raise @context.class.config.input_exception_class.new(
+            context: @context,
+            message: message_text,
+            input_name:
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/context/warehouse/internals.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      class Internals < Base
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      class Outputs < Base
+        extend Forwardable
+        def_delegators :@arguments, :each_pair
+      end
+    end
+  end
+end

data/lib/servactory/context/warehouse/setup.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Context
+    module Warehouse
+      class Setup
+        def initialize(context)
+          @context = context
+        end
+
+        def assign_inputs(arguments)
+          context_data[:inputs].merge!(arguments)
+        end
+
+        def fetch_input(name)
+          inputs.fetch(name, nil)
+        end
+
+        def assign_internal(name, value)
+          assign_attribute(:internals, name, value)
+        end
+
+        def fetch_internal(name)
+          internals.fetch(name, nil)
+        end
+
+        def assign_output(name, value)
+          assign_attribute(:outputs, name, value)
+        end
+
+        def fetch_output(name)
+          outputs.fetch(name, nil)
+        end
+
+        def inputs
+          @inputs ||= context_data.fetch(:inputs)
+        end
+
+        def internals
+          @internals ||= context_data.fetch(:internals)
+        end
+
+        def outputs
+          @outputs ||= context_data.fetch(:outputs)
+        end
+
+        private
+
+        def assign_attribute(section, name, value)
+          context_data[section].assign(name, value)
+        end
+
+        def context_data
+          @context_data ||= state.fetch(context_id)
+        end
+
+        def state
+          {
+            context_id => {
+              inputs: Servactory::Context::Warehouse::Inputs.new(@context),
+              internals: Servactory::Context::Warehouse::Internals.new,
+              outputs: Servactory::Context::Warehouse::Outputs.new
+            }
+          }
+        end
+
+        def context_id
+          @context_id ||= "context_#{@context.object_id}"
+        end
+      end
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Servactory
 
         private
 
-        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize,  Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
         def fetch_with(name:, &block)
           input_name = @context.class.config.predicate_methods_enabled? ? name.to_s.chomp("?").to_sym : name
 
@@ -48,7 +48,7 @@ module Servactory
 
           return yield if input.nil?
 
-          input_value = @context.send(:servactory_service_store).fetch_input(input.name)
+          input_value = @context.send(:servactory_service_warehouse).fetch_input(input.name)
           input_value = input.default if input.optional? && input_value.blank?
 
           if input.hash_mode? && (tmp_schema = input.schema.fetch(:is)).present?
@@ -64,7 +64,7 @@ module Servactory
             input_value
           end
         end
-        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize,  Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Lint/UnusedMethodArgument
+        # 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/context/workspace/internals.rb

@@ -50,7 +50,7 @@ module Servactory
             value:
           )
 
-          @context.send(:servactory_service_store).assign_internal(internal.name, value)
+          @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
         end
 
         def fetch_with(name:, &block) # rubocop:disable Metrics/AbcSize, Lint/UnusedMethodArgument
@@ -59,7 +59,7 @@ module Servactory
 
           return yield if internal.nil?
 
-          internal_value = @context.send(:servactory_service_store).fetch_internal(internal.name)
+          internal_value = @context.send(:servactory_service_warehouse).fetch_internal(internal.name)
 
           if name.to_s.end_with?("?") && @context.class.config.predicate_methods_enabled?
             Servactory::Utils.query_attribute(internal_value)

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

@@ -50,7 +50,7 @@ module Servactory
             value:
           )
 
-          @context.send(:servactory_service_store).assign_output(output.name, value)
+          @context.send(:servactory_service_warehouse).assign_output(output.name, value)
         end
 
         def fetch_with(name:, &block) # rubocop:disable Metrics/AbcSize, Lint/UnusedMethodArgument
@@ -59,7 +59,7 @@ module Servactory
 
           return yield if output.nil?
 
-          output_value = @context.send(:servactory_service_store).fetch_output(output.name)
+          output_value = @context.send(:servactory_service_warehouse).fetch_output(output.name)
 
           if name.to_s.end_with?("?") && @context.class.config.predicate_methods_enabled?
             Servactory::Utils.query_attribute(output_value)

data/lib/servactory/context/workspace.rb

@@ -126,8 +126,8 @@ module Servactory
         @servactory_service_info ||= self.class::Actor.new(self)
       end
 
-      def servactory_service_store
-        @servactory_service_store ||= Store.new(self)
+      def servactory_service_warehouse
+        @servactory_service_warehouse ||= Warehouse::Setup.new(self)
       end
     end
   end

data/lib/servactory/info/builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Info
+    class Builder
+      attr_reader :inputs,
+                  :internals,
+                  :outputs
+
+      def self.build(...)
+        new.build(...)
+      end
+
+      def build(collection_of_inputs:, collection_of_internals:, collection_of_outputs:, config:)
+        dynamic_options = config.input_option_helpers.dynamic_options
+
+        build_inputs_with(collection_of_inputs:, dynamic_options:)
+        build_internals_with(collection_of_internals:, dynamic_options:)
+        build_outputs_with(collection_of_outputs:, dynamic_options:)
+
+        self
+      end
+
+      private
+
+      def build_inputs_with(collection_of_inputs:, dynamic_options:)
+        @inputs = collection_of_inputs.to_h do |input|
+          options = build_options_for(input, dynamic_options)
+          options = enrich_options_for(input, options)
+
+          options[:required] = input.required
+          options[:default] = input.default
+
+          [
+            input.name,
+            options
+          ]
+        end
+      end
+
+      def build_internals_with(collection_of_internals:, dynamic_options:)
+        @internals = collection_of_internals.to_h do |internal|
+          options = build_options_for(internal, dynamic_options)
+          options = enrich_options_for(internal, options)
+
+          [
+            internal.name,
+            options
+          ]
+        end
+      end
+
+      def build_outputs_with(collection_of_outputs:, dynamic_options:)
+        @outputs = collection_of_outputs.to_h do |output|
+          options = build_options_for(output, dynamic_options)
+          options = enrich_options_for(output, options)
+
+          [
+            output.name,
+            options
+          ]
+        end
+      end
+
+      ##########################################################################
+
+      def build_options_for(attribute, dynamic_options)
+        attribute.options.to_h do |key, value|
+          dynamic_option = dynamic_options.find_by(name: key)
+
+          next [nil, nil] if dynamic_option.nil?
+
+          body_key = dynamic_option.meta.fetch(:body_key)
+
+          option = build_option_from(body_key:, value:)
+
+          [
+            dynamic_option.name,
+            option
+          ]
+        end.compact
+      end
+
+      def build_option_from(body_key:, value:)
+        {
+          body_key => value.is_a?(Hash) ? value.fetch(body_key, value) : value,
+          message: value.is_a?(Hash) ? value.fetch(:message, nil) : nil
+        }
+      end
+
+      def enrich_options_for(attribute, options)
+        actor = attribute.class::Actor.new(attribute)
+        must = attribute.collection_of_options.find_by(name: :must)
+
+        options.merge(
+          actor:,
+          types: attribute.types,
+          must: must.body
+        )
+      end
+    end
+  end
+end

data/lib/servactory/info/dsl.rb

@@ -8,58 +8,15 @@ module Servactory
       end
 
       module ClassMethods
-        def info # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          Servactory::Info::Result.new(
-            inputs: collection_of_inputs.to_h do |input|
-              actor = input.class::Actor.new(input)
-              inclusion = input.collection_of_options.find_by(name: :inclusion)
-              must = input.collection_of_options.find_by(name: :must)
-
-              [
-                input.name,
-                {
-                  actor:,
-                  types: input.types,
-                  required: input.required,
-                  default: input.default,
-                  inclusion: inclusion.body,
-                  must: must.body
-                }
-              ]
-            end,
-
-            internals: collection_of_internals.to_h do |internal|
-              actor = internal.class::Actor.new(internal)
-              inclusion = internal.collection_of_options.find_by(name: :inclusion)
-              must = internal.collection_of_options.find_by(name: :must)
-
-              [
-                internal.name,
-                {
-                  actor:,
-                  types: internal.types,
-                  inclusion: inclusion.body,
-                  must: must.body
-                }
-              ]
-            end,
-
-            outputs: collection_of_outputs.to_h do |output|
-              actor = output.class::Actor.new(output)
-              inclusion = output.collection_of_options.find_by(name: :inclusion)
-              must = output.collection_of_options.find_by(name: :must)
-
-              [
-                output.name,
-                {
-                  actor:,
-                  types: output.types,
-                  inclusion: inclusion.body,
-                  must: must.body
-                }
-              ]
-            end
+        def info
+          builder = Builder.build(
+            collection_of_inputs:,
+            collection_of_internals:,
+            collection_of_outputs:,
+            config:
           )
+
+          Result.new(builder)
         end
       end
     end

data/lib/servactory/info/result.rb

@@ -7,10 +7,10 @@ module Servactory
                   :internals,
                   :outputs
 
-      def initialize(inputs:, internals:, outputs:)
-        @inputs = inputs
-        @internals = internals
-        @outputs = outputs
+      def initialize(builder)
+        @inputs = builder.inputs
+        @internals = builder.internals
+        @outputs = builder.outputs
       end
     end
   end

data/lib/servactory/inputs/input.rb

@@ -7,13 +7,15 @@ module Servactory
         attr_reader :name,
                     :internal_name,
                     :types,
-                    :inclusion
+                    :default,
+                    :options
 
-        def initialize(input) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def initialize(input) # rubocop:disable Metrics/MethodLength
           @name = input.name
           @internal_name = input.internal_name
           @types = input.types
-          @inclusion = input.inclusion.slice(:in) if input.inclusion_present?
+          @default = input.default
+          @options = input.options
 
           define_singleton_method(:system_name) { input.system_name }
           define_singleton_method(:i18n_name) { input.i18n_name }
@@ -28,7 +30,8 @@ module Servactory
 
       attr_reader :name,
                   :internal_name,
-                  :collection_of_options
+                  :collection_of_options,
+                  :options
 
       # rubocop:disable Style/KeywordParametersOrder
       def initialize(
@@ -75,12 +78,12 @@ module Servactory
             types: true,
             default: true,
             hash: true,
-            inclusion: true,
             must: true,
             prepare: true
           }
         )
 
+        @options = options
         @collection_of_options = options_registrar.collection
       end
 

data/lib/servactory/inputs/tools/unnecessary.rb

@@ -31,7 +31,7 @@ module Servactory
 
         def unnecessary_attributes
           @unnecessary_attributes ||=
-            @context.send(:servactory_service_store).inputs.keys -
+            @context.send(:servactory_service_warehouse).inputs.names -
             @collection_of_inputs.names
         end
       end