servactory 2.5.1 → 2.6.0.rc1

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

@@ -20,7 +20,6 @@ module Servactory
             required: false,
             types: false,
             default: false,
-            collection: false,
             hash: false,
             inclusion: false,
             must: false,
@@ -33,9 +32,8 @@ module Servactory
             new(...).register
           end
 
-          def initialize(attribute:, collection_mode_class_names:, hash_mode_class_names:, options:, features:)
+          def initialize(attribute:, 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)
@@ -43,14 +41,13 @@ module Servactory
 
           ########################################################################
 
-          def register # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def register # rubocop:disable Metrics/CyclomaticComplexity
             # Validation Class: Servactory::Inputs::Validations::Required
             register_required_option if @features.fetch(:required)
 
             # Validation Class: Servactory::Maintenance::Attributes::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)
 
             # Validation Class: Servactory::Maintenance::Attributes::Validations::Inclusion
@@ -124,35 +121,6 @@ module Servactory
             )
           end
 
-          def register_collection_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
-              name: :consists_of,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Type,
-              define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
-                  name: :collection_mode?,
-                  content: lambda do |**|
-                    @collection_mode_class_names.include?(@options.fetch(:type)) &&
-                      @options.fetch(:consists_of, true) != false
-                  end
-                )
-              ],
-              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,

data/lib/servactory/maintenance/attributes/translator/inclusion.rb

@@ -8,12 +8,11 @@ module Servactory
           module_function
 
           def default_message
-            lambda do |service_class_name:, value:, input: nil, internal: nil, output: nil|
+            lambda do |service:, value:, input: nil, internal: nil, output: nil|
               attribute = Servactory::Utils.define_attribute_with(input: input, internal: internal, output: output)
 
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.inclusion.default_error",
-                service_class_name: service_class_name,
+              service.translate(
+                "#{attribute.i18n_name}.validations.inclusion.default_error",
                 "#{attribute.system_name}_name": attribute.name,
                 "#{attribute.system_name}_inclusion": attribute.inclusion[:in],
                 value: value

data/lib/servactory/maintenance/attributes/translator/must.rb

@@ -7,13 +7,12 @@ module Servactory
         module Must
           module_function
 
-          def default_message # rubocop:disable Metrics/MethodLength
-            lambda do |service_class_name:, value:, code:, input: nil, internal: nil, output: nil, reason: nil|
+          def default_message
+            lambda do |service:, value:, code:, input: nil, internal: nil, output: nil, reason: nil|
               attribute = Servactory::Utils.define_attribute_with(input: input, internal: internal, output: output)
 
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.must.default_error",
-                service_class_name: service_class_name,
+              service.translate(
+                "#{attribute.i18n_name}.validations.must.default_error",
                 "#{attribute.system_name}_name": attribute.name,
                 value: value,
                 code: code,
@@ -22,13 +21,12 @@ module Servactory
             end
           end
 
-          def syntax_error_message # rubocop:disable Metrics/MethodLength
-            lambda do |service_class_name:, value:, code:, exception_message:, input: nil, internal: nil, output: nil|
+          def syntax_error_message
+            lambda do |service:, value:, code:, exception_message:, input: nil, internal: nil, output: nil|
               attribute = Servactory::Utils.define_attribute_with(input: input, internal: internal, output: output)
 
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.must.syntax_error",
-                service_class_name: service_class_name,
+              service.translate(
+                "#{attribute.i18n_name}.validations.must.syntax_error",
                 "#{attribute.system_name}_name": attribute.name,
                 value: value,
                 code: code,

data/lib/servactory/maintenance/attributes/translator/type.rb

@@ -7,16 +7,13 @@ module Servactory
         module Type
           extend self
 
-          def default_message # rubocop:disable Metrics/MethodLength
-            lambda do |service_class_name:, attribute:, value:, key_name:, expected_type:, given_type:|
-              if attribute.collection_mode?
-                for_collection_mode_with(service_class_name: service_class_name, attribute: attribute, value: value,
-                                         expected_type: expected_type, given_type: given_type)
-              elsif attribute.hash_mode? && key_name.present?
-                for_hash_mode_with(service_class_name: service_class_name, attribute: attribute, key_name: key_name,
+          def default_message
+            lambda do |service:, attribute:, key_name:, expected_type:, given_type:, **|
+              if attribute.hash_mode? && key_name.present?
+                for_hash_mode_with(service: service, attribute: attribute, key_name: key_name,
                                    expected_type: expected_type, given_type: given_type)
               else
-                for_others_with(service_class_name: service_class_name, attribute: attribute,
+                for_others_with(service: service, attribute: attribute,
                                 expected_type: expected_type, given_type: given_type)
               end
             end
@@ -24,37 +21,7 @@ module Servactory
 
           private
 
-          def for_collection_mode_with(service_class_name:, attribute:, value:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-            collection_message = attribute.consists_of.fetch(:message)
-
-            if collection_message.is_a?(Proc)
-              collection_message.call(
-                **Servactory::Utils.fetch_hash_with_desired_attribute(attribute),
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            elsif collection_message.is_a?(String) && collection_message.present?
-              collection_message
-            elsif value.is_a?(attribute.types.fetch(0, Array))
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_element_type",
-                service_class_name: service_class_name,
-                "#{attribute.system_name}_name": attribute.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            else
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_type",
-                service_class_name: service_class_name,
-                "#{attribute.system_name}_name": attribute.name,
-                expected_type: attribute.types.fetch(0, Array),
-                given_type: value.class.name
-              )
-            end
-          end
-
-          def for_hash_mode_with(service_class_name:, attribute:, key_name:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength
+          def for_hash_mode_with(service:, attribute:, key_name:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength
             hash_message = attribute.schema.fetch(:message)
 
             if hash_message.is_a?(Proc)
@@ -67,9 +34,8 @@ module Servactory
             elsif hash_message.is_a?(String) && hash_message.present?
               hash_message
             else
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_hash.wrong_element_type",
-                service_class_name: service_class_name,
+              service.translate(
+                "#{attribute.i18n_name}.validations.type.default_error.for_hash.wrong_element_type",
                 "#{attribute.system_name}_name": attribute.name,
                 key_name: key_name,
                 expected_type: expected_type,
@@ -78,10 +44,9 @@ module Servactory
             end
           end
 
-          def for_others_with(service_class_name:, attribute:, expected_type:, given_type:)
-            I18n.t(
-              "servactory.#{attribute.i18n_name}.validations.type.default_error.default",
-              service_class_name: service_class_name,
+          def for_others_with(service:, attribute:, expected_type:, given_type:)
+            service.translate(
+              "#{attribute.i18n_name}.validations.type.default_error.default",
               "#{attribute.system_name}_name": attribute.name,
               expected_type: expected_type,
               given_type: given_type

data/lib/servactory/maintenance/attributes/validations/inclusion.rb

@@ -51,7 +51,7 @@ module Servactory
           def add_error_with(message)
             add_error(
               message: message.presence || Servactory::Maintenance::Attributes::Translator::Inclusion.default_message,
-              service_class_name: @context.class.name,
+              service: @context.send(:servactory_service_info),
               **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value
             )

data/lib/servactory/maintenance/attributes/validations/must.rb

@@ -65,7 +65,7 @@ module Servactory
           def add_error_with(message, code, reason)
             add_error(
               message: message,
-              service_class_name: @context.class.name,
+              service: @context.send(:servactory_service_info),
               **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value,
               code: code,
@@ -76,7 +76,7 @@ module Servactory
           def add_syntax_error_with(message, code, exception_message)
             add_error(
               message: message,
-              service_class_name: @context.class.name,
+              service: @context.send(:servactory_service_info),
               **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value,
               code: code,

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

@@ -17,18 +17,9 @@ module Servactory
         end
 
         def validate! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          collection_validator = nil
           object_schema_validator = nil
 
-          if @attribute.collection_mode?
-            collection_validator = Servactory::Maintenance::Validations::Collection.validate(
-              types: @types,
-              value: @value,
-              consists_of: @attribute.consists_of
-            )
-
-            return if collection_validator.valid?
-          elsif @attribute.hash_mode?
+          if @attribute.hash_mode?
             object_schema_validator = Servactory::Maintenance::Validations::ObjectSchema.validate(
               object: @value,
               schema: @attribute.schema
@@ -41,22 +32,10 @@ module Servactory
             end
           end
 
-          if (first_error = collection_validator&.errors&.first).present?
-            return @error_callback.call(
-              message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
-              service_class_name: @context.class.name,
-              attribute: @attribute,
-              value: @value,
-              key_name: nil,
-              expected_type: first_error.fetch(:expected_type),
-              given_type: first_error.fetch(:given_type)
-            )
-          end
-
           if (first_error = object_schema_validator&.errors&.first).present?
             return @error_callback.call(
               message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
-              service_class_name: @context.class.name,
+              service: @context.send(:servactory_service_info),
               attribute: @attribute,
               value: @value,
               key_name: first_error.fetch(:key_name),
@@ -67,7 +46,7 @@ module Servactory
 
           @error_callback.call(
             message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
-            service_class_name: @context.class.name,
+            service: @context.send(:servactory_service_info),
             attribute: @attribute,
             value: @value,
             key_name: nil,
@@ -79,12 +58,7 @@ module Servactory
         private
 
         def prepared_types
-          @prepared_types ||=
-            if @attribute.collection_mode?
-              prepared_types_from(Array(@attribute.consists_of.fetch(:type, [])))
-            else
-              prepared_types_from(@types)
-            end
+          @prepared_types ||= prepared_types_from(@types)
         end
 
         def prepared_types_from(types)

data/lib/servactory/outputs/dsl.rb

@@ -20,7 +20,6 @@ module Servactory
           collection_of_outputs << Output.new(
             name,
             *helpers,
-            collection_mode_class_names: config.collection_mode_class_names,
             hash_mode_class_names: config.hash_mode_class_names,
             option_helpers: config.output_option_helpers,
             **options

data/lib/servactory/outputs/output.rb

@@ -3,7 +3,7 @@
 module Servactory
   module Outputs
     class Output
-      class Work
+      class Actor
         attr_reader :name,
                     :types,
                     :inclusion
@@ -28,13 +28,11 @@ module Servactory
       def initialize(
         name,
         *helpers,
-        collection_mode_class_names:,
         hash_mode_class_names:,
         option_helpers:,
         **options
       )
         @name = name
-        @collection_mode_class_names = collection_mode_class_names
         @hash_mode_class_names = hash_mode_class_names
         @option_helpers = option_helpers
 
@@ -61,12 +59,10 @@ module Servactory
 
         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: {
             types: true,
-            collection: true,
             hash: true,
             inclusion: true,
             must: true
@@ -94,7 +90,7 @@ module Servactory
           prepared_options.deep_merge!(prepared_option)
         end
 
-        options.merge(prepared_options)
+        options.deep_merge(prepared_options)
       end
 
       def options_for_checks

data/lib/servactory/result.rb

@@ -121,9 +121,8 @@ module Servactory
 
       raise @context.class.config.failure_class.new(
         type: :base,
-        message: I18n.t(
-          "servactory.common.undefined_method.missing_name",
-          service_class_name: @context.class.name,
+        message: @context.send(:servactory_service_info).translate(
+          "common.undefined_method.missing_name",
           error_text: exception.message
         ),
         meta: {

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/consists_of_matcher.rb

@@ -50,68 +50,20 @@ module Servactory
                         :attribute_data
 
             def submatcher_passes?(_subject)
-              attribute_consists_of = Array(attribute_data.fetch(:consists_of).fetch(:type) || [])
+              attribute_must = attribute_data.fetch(:must)
 
-              matched = attribute_consists_of.difference(consists_of_types).empty?
+              attribute_must_keys = attribute_must.keys
 
-              matched &&= attribute_consists_of_message.casecmp(custom_message).zero? if custom_message.present?
+              expected_keys = %i[consists_of]
 
-              matched
-            end
-
-            def attribute_consists_of_message # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              attribute_consists_of_message = attribute_data.fetch(:consists_of).fetch(:message)
+              attribute_must_keys = attribute_must_keys.select { |key| expected_keys.include?(key) }
 
-              if attribute_consists_of_message.nil?
-                I18n.t(
-                  "servactory.#{attribute_type_plural}.validations.required.default_error.for_collection",
-                  service_class_name: described_class.name,
-                  "#{attribute_type}_name": attribute_name
-                )
-              elsif attribute_consists_of_message.is_a?(Proc)
-                input_work = attribute_data.fetch(:work)
-
-                attribute_consists_of_message.call(
-                  input: input_work,
-                  expected_type: String,
-                  given_type: Servactory::TestKit::FakeType.new.class.name
-                )
-              else
-                attribute_consists_of_message
-              end
+              attribute_must_keys.difference(expected_keys).empty? &&
+                expected_keys.difference(attribute_must_keys).empty?
             end
 
-            def build_missing_option # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              attribute_consists_of = Array(attribute_data.fetch(:consists_of).fetch(:type) || [])
-
-              unless attribute_consists_of.difference(consists_of_types).empty?
-                text_about_types = option_types.size > 1 ? "the following types" : "type"
-
-                return <<~MESSAGE
-                  should be a collection consisting of #{text_about_types}
-
-                    expected #{consists_of_types.inspect}
-                         got #{attribute_consists_of.inspect}
-                MESSAGE
-              end
-
-              if custom_message.present? && !attribute_consists_of_message.casecmp(custom_message).zero?
-                return <<~MESSAGE
-                  should be a collection with a message
-
-                    expected #{custom_message.inspect}
-                         got #{attribute_consists_of_message.inspect}
-                MESSAGE
-              end
-
-              <<~MESSAGE
-                got an unexpected case when using `consists_of`
-
-                Please try to build an example based on the documentation.
-                Or report your problem to us:
-
-                  https://github.com/servactory/servactory/issues
-              MESSAGE
+            def build_missing_option
+              "should be consists_of"
             end
           end
         end

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/must_matcher.rb

@@ -46,8 +46,13 @@ module Servactory
             def submatcher_passes?(_subject)
               attribute_must = attribute_data.fetch(:must)
 
-              attribute_must.keys.difference(must_names).empty? &&
-                must_names.difference(attribute_must.keys).empty?
+              attribute_must_keys = attribute_must.keys
+
+              # NOTE: Even though the dynamic option `consists_of` is a `must`, here we are testing explicit `must`.
+              attribute_must_keys.delete(:consists_of)
+
+              attribute_must_keys.difference(must_names).empty? &&
+                must_names.difference(attribute_must_keys).empty?
             end
 
             def build_missing_option

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matcher.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "have_service_input_matchers/default_matcher"
+require_relative "have_service_input_matchers/optional_matcher"
+require_relative "have_service_input_matchers/required_matcher"
+require_relative "have_service_input_matchers/valid_with_matcher"
+
 module Servactory
   module TestKit
     module Rspec

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/required_matcher.rb

@@ -17,6 +17,8 @@ module Servactory
 
               @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
 
+              @i18n_root_key = described_class.config.i18n_root_key
+
               @missing_option = ""
             end
 
@@ -41,7 +43,8 @@ module Servactory
                         :attribute_type_plural,
                         :attribute_name,
                         :custom_message,
-                        :attribute_data
+                        :attribute_data,
+                        :i18n_root_key
 
             def submatcher_passes?(_subject) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
               attribute_required = attribute_data.fetch(:required).fetch(:is)
@@ -51,7 +54,7 @@ module Servactory
 
               if attribute_required_message.nil?
                 attribute_required_message = I18n.t(
-                  "servactory.#{attribute_type_plural}.validations.required.default_error.default",
+                  "#{i18n_root_key}.#{attribute_type_plural}.validations.required.default_error.default",
                   service_class_name: described_class.name,
                   "#{attribute_type}_name": attribute_name
                 )

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/valid_with_matcher.rb

@@ -17,6 +17,8 @@ module Servactory
 
               @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
 
+              @i18n_root_key = described_class.config.i18n_root_key
+
               @missing_option = ""
             end
 
@@ -41,7 +43,8 @@ module Servactory
                         :attribute_type_plural,
                         :attribute_name,
                         :attributes,
-                        :attribute_data
+                        :attribute_data,
+                        :i18n_root_key
 
             def submatcher_passes?(_subject) # rubocop:disable Metrics/CyclomaticComplexity
               success_passes? &&
@@ -60,41 +63,18 @@ module Servactory
 
             def failure_type_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
               option_types = attribute_data.fetch(:types)
-              input_first_type = option_types.first
-              input_required = attribute_data.fetch(:required).fetch(:is)
-              attribute_consists_of_types = Array(attribute_data.fetch(:consists_of).fetch(:type))
-              attribute_consists_of_first_type = attribute_consists_of_types.first
 
               prepared_attributes = attributes.dup
               prepared_attributes[attribute_name] = Servactory::TestKit::FakeType.new
 
               input_required_message =
-                if described_class.config.collection_mode_class_names.include?(input_first_type) &&
-                   attribute_consists_of_first_type != false
-                  if input_required
-                    I18n.t(
-                      "servactory.#{attribute_type_plural}.validations.required.default_error.for_collection",
-                      service_class_name: described_class.name,
-                      "#{attribute_type}_name": attribute_name
-                    )
-                  else
-                    I18n.t(
-                      "servactory.#{attribute_type_plural}.validations.type.default_error.for_collection.wrong_type",
-                      service_class_name: described_class.name,
-                      "#{attribute_type}_name": attribute_name,
-                      expected_type: option_types.join(", "),
-                      given_type: Servactory::TestKit::FakeType.new.class.name
-                    )
-                  end
-                else
-                  I18n.t(
-                    "servactory.#{attribute_type_plural}.validations.type.default_error.default",
-                    service_class_name: described_class.name,
-                    "#{attribute_type}_name": attribute_name,
-                    expected_type: option_types.join(", "),
-                    given_type: Servactory::TestKit::FakeType.new.class.name
-                  )
-                end
+                I18n.t(
+                  "#{i18n_root_key}.#{attribute_type_plural}.validations.type.default_error.default",
+                  service_class_name: described_class.name,
+                  "#{attribute_type}_name": attribute_name,
+                  expected_type: option_types.join(", "),
+                  given_type: Servactory::TestKit::FakeType.new.class.name
+                )
 
               expect_failure_with!(prepared_attributes, input_required_message)
             end
@@ -111,7 +91,7 @@ module Servactory
 
               if input_required_message.nil?
                 input_required_message = I18n.t(
-                  "servactory.#{attribute_type_plural}.validations.required.default_error.default",
+                  "#{i18n_root_key}.#{attribute_type_plural}.validations.required.default_error.default",
                   service_class_name: described_class.name,
                   "#{attribute_type}_name": attribute_name
                 )
@@ -131,38 +111,14 @@ module Servactory
               expect_failure_with!(prepared_attributes, nil)
             end
 
-            def failure_format_passes?
-              # NOTE: Checking for negative cases is not implemented for `format`
+            def failure_consists_of_passes?
+              # NOTE: Checking for negative cases is not implemented for `consists_of`
               true
             end
 
-            def failure_consists_of_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              option_types = attribute_data.fetch(:types)
-              input_first_type = option_types.first
-
-              return true unless described_class.config.collection_mode_class_names.include?(input_first_type)
-
-              prepared_attributes = attributes.dup
-              prepared_attributes[attribute_name] = input_first_type[Servactory::TestKit::FakeType.new]
-
-              attribute_consists_of_types = Array(attribute_data.fetch(:consists_of).fetch(:type))
-              attribute_consists_of_first_type = attribute_consists_of_types.first
-
-              return true if attribute_consists_of_first_type == false
-
-              attribute_consists_of_message = attribute_data.fetch(:consists_of).fetch(:message)
-
-              if attribute_consists_of_message.nil?
-                attribute_consists_of_message = I18n.t(
-                  "servactory.#{attribute_type_plural}.validations.type.default_error.for_collection.wrong_element_type", # rubocop:disable Layout/LineLength
-                  service_class_name: described_class.name,
-                  "#{attribute_type}_name": attribute_name,
-                  expected_type: attribute_consists_of_types.join(", "),
-                  given_type: prepared_attributes[attribute_name].map { _1.class.name }.join(", ")
-                )
-              end
-
-              expect_failure_with!(prepared_attributes, attribute_consists_of_message)
+            def failure_format_passes?
+              # NOTE: Checking for negative cases is not implemented for `format`
+              true
             end
 
             def failure_inclusion_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
@@ -179,7 +135,7 @@ module Servactory
 
               if input_required_message.nil?
                 input_required_message = I18n.t(
-                  "servactory.#{attribute_type_plural}.validations.inclusion.default_error",
+                  "#{i18n_root_key}.#{attribute_type_plural}.validations.inclusion.default_error",
                   service_class_name: described_class.name,
                   "#{attribute_type}_name": attribute_name,
                   "#{attribute_type}_inclusion": input_inclusion_in,

data/lib/servactory/test_kit/rspec/matchers/have_service_internal_matcher.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+require_relative "have_service_attribute_matchers/types_matcher"
+require_relative "have_service_attribute_matchers/consists_of_matcher"
+require_relative "have_service_attribute_matchers/inclusion_matcher"
+require_relative "have_service_attribute_matchers/must_matcher"
+
 module Servactory
   module TestKit
     module Rspec

data/lib/servactory/test_kit/rspec/matchers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "rspec/expectations"
+require_relative "matchers/have_service_input_matcher"
+require_relative "matchers/have_service_internal_matcher"
 
 module Servactory
   module TestKit