servactory 2.14.0 → 2.15.0.rc1

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

@@ -3,7 +3,7 @@
 module Servactory
   module Maintenance
     module Attributes
-      class Option
+      class Option # rubocop:disable Metrics/ClassLength
         DEFAULT_BODY = ->(key:, body:, message: nil) { { key => body, message: } }
 
         private_constant :DEFAULT_BODY
@@ -29,14 +29,14 @@ module Servactory
           define_conflicts: nil,
           with_advanced_mode: true,
           **options
-        ) # do
+        )
           @name = name.to_sym
           @validation_class = validation_class
           @define_methods = define_methods
           @define_conflicts = define_conflicts
           @need_for_checks = need_for_checks
 
-          @body = prepare_value_for(
+          @body = construct_body(
             original_value:,
             options:,
             body_key:,
@@ -45,7 +45,7 @@ module Servactory
             with_advanced_mode:
           )
 
-          prepare_methods_for(attribute)
+          apply_dynamic_methods_to(attribute:)
         end
         # rubocop:enable Metrics/MethodLength
 
@@ -55,7 +55,7 @@ module Servactory
 
         private
 
-        def prepare_value_for(
+        def construct_body(
           original_value:,
           options:,
           body_key:,
@@ -64,44 +64,78 @@ module Servactory
           with_advanced_mode:
         )
           return original_value if original_value.present?
-
           return options.fetch(@name, body_fallback) unless with_advanced_mode
 
-          prepare_advanced_for(
-            body: options.fetch(@name, DEFAULT_BODY.call(key: body_key, body: body_fallback)),
+          use_advanced_mode(
+            options:,
             body_key:,
             body_value:,
             body_fallback:
           )
         end
 
-        def prepare_advanced_for(
-          body:,
-          body_key:,
-          body_value:,
-          body_fallback:
-        )
+        def use_advanced_mode(options:, body_key:, body_value:, body_fallback:)
+          default_body = create_default_body(body_key:, body_fallback:)
+          body = extract_body_from_options(options:, default_body:)
+
+          construct_advanced_body(
+            body:,
+            body_key:,
+            body_value:,
+            body_fallback:
+          )
+        end
+
+        def create_default_body(body_key:, body_fallback:)
+          DEFAULT_BODY.call(key: body_key, body: body_fallback)
+        end
+
+        def extract_body_from_options(options:, default_body:)
+          options.fetch(@name, default_body)
+        end
+
+        def construct_advanced_body(body:, body_key:, body_value:, body_fallback:)
           if body.is_a?(Hash)
-            message = body.fetch(:message, nil)
+            build_hash_body(body:, body_key:, body_value:, body_fallback:)
+          else
+            build_simple_body(body_key:, body:)
+          end
+        end
 
-            DEFAULT_BODY.call(
-              key: body_key,
-              body: body.fetch(body_key, message.present? ? body_value : body_fallback),
-              message:
-            )
+        def build_hash_body(body:, body_key:, body_value:, body_fallback:)
+          message = body[:message]
+          body_content = extract_body_content(
+            body:,
+            body_key:,
+            body_value:,
+            body_fallback:,
+            message:
+          )
+          DEFAULT_BODY.call(key: body_key, body: body_content, message:)
+        end
+
+        def extract_body_content(body:, body_key:, body_value:, body_fallback:, message:)
+          if message.present?
+            body.fetch(body_key, body_value)
           else
-            DEFAULT_BODY.call(key: body_key, body:)
+            body.fetch(body_key, body_fallback)
           end
         end
 
-        def prepare_methods_for(attribute)
-          attribute.instance_eval(define_methods_template) if define_methods_template.present?
+        def build_simple_body(body_key:, body:)
+          DEFAULT_BODY.call(key: body_key, body:)
+        end
+
+        def apply_dynamic_methods_to(attribute:)
+          return if @define_methods.blank?
+
+          attribute.instance_eval(generate_methods_code)
         end
 
-        def define_methods_template
+        def generate_methods_code
           return if @define_methods.blank?
 
-          @define_methods_template ||= @define_methods.map do |define_method|
+          @define_methods.map do |define_method|
             <<-RUBY.squish
               def #{define_method.name};
                 #{define_method.content.call(option: @body)};

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

@@ -37,56 +37,46 @@ module Servactory
           ########################################################################
 
           def register
-            # Validation Class: Servactory::Inputs::Validations::Required
-            register_required_option if @features.fetch(:required)
+            register_feature(:required, Servactory::Inputs::Validations::Required)
+            register_feature(:types, Servactory::Maintenance::Attributes::Validations::Type)
+            register_feature(:default, Servactory::Maintenance::Attributes::Validations::Type)
+            register_feature(:must, Servactory::Maintenance::Attributes::Validations::Must)
+            register_feature(:prepare, nil)
 
-            # Validation Class: Servactory::Maintenance::Attributes::Validations::Type
-            register_types_option if @features.fetch(:types)
-            register_default_option if @features.fetch(:default)
+            self
+          end
 
-            # Validation Class: Servactory::Maintenance::Attributes::Validations::Must
-            register_must_option if @features.fetch(:must)
+          def collection
+            @collection ||= Servactory::Maintenance::Attributes::OptionsCollection.new
+          end
 
-            # Validation Class: nil
-            register_prepare_option if @features.fetch(:prepare)
+          private
 
-            self
+          def register_feature(feature_name, validation_class)
+            return unless @features.fetch(feature_name)
+
+            method_name = "register_#{feature_name}_option"
+            send(method_name, validation_class)
           end
 
           ########################################################################
 
-          def register_required_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
+          def register_required_option(validation_class)
+            create_option(
               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? }
-                )
-              ],
+              validation_class:,
+              define_methods: required_define_methods,
+              define_conflicts: required_define_conflicts,
               need_for_checks: true,
               body_key: :is,
-              body_fallback: true,
-              **@options
+              body_fallback: true
             )
           end
 
-          def register_types_option
-            collection << Servactory::Maintenance::Attributes::Option.new(
+          def register_types_option(validation_class)
+            create_option(
               name: :types,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Type,
+              validation_class:,
               original_value: Array(@options.fetch(:type)).uniq,
               need_for_checks: true,
               body_fallback: nil,
@@ -94,31 +84,28 @@ module Servactory
             )
           end
 
-          def register_default_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
+          def register_default_option(validation_class) # rubocop:disable Metrics/MethodLength
+            create_option(
               name: :default,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Type,
+              validation_class:,
               define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
+                create_define_method(
                   name: :default_value_present?,
                   content: ->(option:) { !option.nil? }
                 )
               ],
               need_for_checks: true,
               body_fallback: nil,
-              with_advanced_mode: false,
-              **@options
+              with_advanced_mode: false
             )
           end
 
-          def register_must_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
+          def register_must_option(validation_class) # rubocop:disable Metrics/MethodLength
+            create_option(
               name: :must,
-              attribute: @attribute,
-              validation_class: Servactory::Maintenance::Attributes::Validations::Must,
+              validation_class:,
               define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
+                create_define_method(
                   name: :must_present?,
                   content: ->(option:) { option.present? }
                 )
@@ -126,33 +113,66 @@ module Servactory
               need_for_checks: true,
               body_key: :is,
               body_fallback: nil,
-              with_advanced_mode: false,
-              **@options
+              with_advanced_mode: false
             )
           end
 
-          def register_prepare_option # rubocop:disable Metrics/MethodLength
-            collection << Servactory::Maintenance::Attributes::Option.new(
+          def register_prepare_option(_validation_class) # rubocop:disable Metrics/MethodLength
+            create_option(
               name: :prepare,
-              attribute: @attribute,
               validation_class: nil,
               define_methods: [
-                Servactory::Maintenance::Attributes::DefineMethod.new(
+                create_define_method(
                   name: :prepare_present?,
                   content: ->(option:) { option[:in].present? }
                 )
               ],
               need_for_checks: false,
               body_key: :in,
-              body_fallback: false,
-              **@options
+              body_fallback: false
             )
           end
 
           ########################################################################
 
-          def collection
-            @collection ||= Servactory::Maintenance::Attributes::OptionsCollection.new
+          def required_define_methods
+            [
+              create_define_method(
+                name: :required?,
+                content: ->(option:) { Servactory::Utils.true?(option[:is]) }
+              ),
+              create_define_method(
+                name: :optional?,
+                content: ->(option:) { !Servactory::Utils.true?(option[:is]) }
+              )
+            ]
+          end
+
+          def required_define_conflicts
+            [
+              Servactory::Maintenance::Attributes::DefineConflict.new(
+                content: -> { :required_vs_default if @attribute.required? && @attribute.default_value_present? }
+              )
+            ]
+          end
+
+          ########################################################################
+
+          def create_option(name:, validation_class:, **options)
+            collection << Servactory::Maintenance::Attributes::Option.new(
+              name:,
+              attribute: @attribute,
+              validation_class:,
+              **options,
+              **@options
+            )
+          end
+
+          def create_define_method(name:, content:)
+            Servactory::Maintenance::Attributes::DefineMethod.new(
+              name:,
+              content:
+            )
           end
         end
       end

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

@@ -5,9 +5,10 @@ module Servactory
     module Attributes
       class OptionsCollection
         extend Forwardable
-        def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :find
 
-        def initialize(*)
+        def_delegators :@collection, :<<, :filter, :each, :map, :flat_map, :find, :empty?, :size
+
+        def initialize
           @collection = Set.new
         end
 
@@ -16,32 +17,41 @@ module Servactory
         end
 
         def validation_classes
-          filter { |option| option.validation_class.present? }.map(&:validation_class).uniq
+          filter { |option| option.validation_class.present? }
+            .map(&:validation_class)
+            .uniq
         end
 
         def options_for_checks
           filter(&:need_for_checks?).to_h do |option|
-            option_body = if option.body.is_a?(Hash)
-                            option.body.key?(:is) ? option.body.fetch(:is) : option.body
-                          else
-                            option.body
-                          end
-
-            [option.name, option_body]
+            [option.name, extract_normalized_body_from(option:)]
           end
         end
 
         def defined_conflict_code
-          flat_map do |option|
-            option.define_conflicts&.map do |define_input_conflict|
-              define_input_conflict.content.call
-            end
-          end.reject(&:blank?).first
+          flat_map { |option| resolve_conflicts_from(option:) }
+            .reject(&:blank?)
+            .first
         end
 
         def find_by(name:)
           find { |option| option.name == name }
         end
+
+        private
+
+        def extract_normalized_body_from(option:)
+          body = option.body
+          return body unless body.is_a?(Hash)
+
+          body.key?(:is) ? body.fetch(:is) : body
+        end
+
+        def resolve_conflicts_from(option:)
+          return [] unless option.define_conflicts
+
+          option.define_conflicts.map { |conflict| conflict.content.call }
+        end
       end
     end
   end

data/lib/servactory/maintenance/attributes/tools/validation.rb

@@ -58,7 +58,7 @@ module Servactory
           ########################################################################
 
           def validation_classes
-            @attribute.collection_of_options.validation_classes
+            @validation_classes ||= @attribute.collection_of_options.validation_classes
           end
 
           ########################################################################

data/lib/servactory/outputs/output.rb

@@ -13,12 +13,23 @@ module Servactory
           @types = output.types
           @options = output.options
 
-          define_singleton_method(:system_name) { output.system_name }
-          define_singleton_method(:i18n_name) { output.i18n_name }
-          # The methods below are required to support the internal work.
-          define_singleton_method(:input?) { false }
-          define_singleton_method(:internal?) { false }
-          define_singleton_method(:output?) { true }
+          define_identity_methods(output)
+        end
+
+        private
+
+        def define_identity_methods(output)
+          methods_map = {
+            system_name: -> { output.system_name },
+            i18n_name: -> { output.i18n_name },
+            input?: -> { false },
+            internal?: -> { false },
+            output?: -> { true }
+          }
+
+          methods_map.each do |method_name, implementation|
+            define_singleton_method(method_name, &implementation)
+          end
         end
       end
 
@@ -40,7 +51,6 @@ module Servactory
 
       def method_missing(name, *args, &block)
         option = @collection_of_options.find_by(name:)
-
         return super if option.nil?
 
         option.body
@@ -50,46 +60,14 @@ module Servactory
         @collection_of_options.names.include?(name) || super
       end
 
-      def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        advanced_helpers = options.except(*Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS)
-
-        options = apply_helpers_for_options(helpers:, options:) if helpers.present?
-        options = apply_helpers_for_options(helpers: advanced_helpers, options:) if advanced_helpers.present?
-
-        options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
-          attribute: self,
-          options:,
-          features: {
-            types: true,
-            must: true
-          }
-        )
+      def register_options(helpers:, options:)
+        merged_options = augment_options_with_helpers(helpers:, options:)
+        options_registrar = create_options_registrar(options: merged_options)
 
-        @options = options
+        @options = merged_options
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
-        prepared_options = {}
-
-        helpers.each do |(helper, values)|
-          found_helper = @option_helpers.find_by(name: helper)
-
-          next if found_helper.blank?
-
-          prepared_option =
-            if found_helper.equivalent.is_a?(Proc)
-              values.is_a?(Hash) ? found_helper.equivalent.call(**values) : found_helper.equivalent.call(values)
-            else
-              found_helper.equivalent
-            end
-
-          prepared_options.deep_merge!(prepared_option)
-        end
-
-        options.deep_merge(prepared_options)
-      end
-
       def options_for_checks
         @collection_of_options.options_for_checks
       end
@@ -113,6 +91,68 @@ module Servactory
       def output?
         true
       end
+
+      private
+
+      def create_options_registrar(options:)
+        Servactory::Maintenance::Attributes::Options::Registrar.register(
+          attribute: self,
+          options:,
+          features: available_feature_options
+        )
+      end
+
+      def available_feature_options
+        {
+          types: true,
+          must: true
+        }
+      end
+
+      def augment_options_with_helpers(helpers:, options:)
+        result_options = options.dup
+        merge_standard_helpers_into(target_options: result_options, helpers:) if helpers.present?
+        merge_advanced_helpers_into(target_options: result_options, source_options: options)
+        result_options
+      end
+
+      def merge_standard_helpers_into(target_options:, helpers:)
+        standard_helpers_result = transform_helpers_to_options(helpers:)
+        target_options.deep_merge!(standard_helpers_result)
+      end
+
+      def merge_advanced_helpers_into(target_options:, source_options:)
+        advanced_helpers = filter_advanced_helpers(options: source_options)
+        return if advanced_helpers.blank?
+
+        advanced_helpers_result = transform_helpers_to_options(helpers: advanced_helpers)
+        target_options.deep_merge!(advanced_helpers_result)
+      end
+
+      def filter_advanced_helpers(options:)
+        reserved_options = Servactory::Maintenance::Attributes::Options::Registrar::RESERVED_OPTIONS
+        options.except(*reserved_options)
+      end
+
+      def transform_helpers_to_options(helpers:)
+        helpers.each_with_object({}) do |(helper_name, values), result|
+          helper = @option_helpers.find_by(name: helper_name)
+          next if helper.blank?
+
+          transformed_option = transform_helper_to_option(helper:, values:)
+          result.deep_merge!(transformed_option) if transformed_option.present?
+        end
+      end
+
+      def transform_helper_to_option(helper:, values:)
+        return helper.equivalent unless helper.equivalent.is_a?(Proc)
+
+        if values.is_a?(Hash)
+          helper.equivalent.call(**values)
+        else
+          helper.equivalent.call(values)
+        end
+      end
     end
   end
 end

data/lib/servactory/result.rb

@@ -44,11 +44,10 @@ module Servactory
     end
 
     def to_h
-      filtered = methods(false).filter do |key|
-        !key.in?(STATE_PREDICATE_NAMES) && !key.to_s.end_with?("?")
-      end
-
-      filtered.to_h { |key| [key, public_send(key)] }.compact
+      methods(false)
+        .reject { |key| key.in?(STATE_PREDICATE_NAMES) || key.to_s.end_with?("?") }
+        .to_h { |key| [key, public_send(key)] }
+        .compact
     end
 
     def inspect
@@ -67,7 +66,7 @@ module Servactory
       self
     end
 
-    def method_missing(name, *_args)
+    def method_missing(name, *args, &block)
       super
     rescue NoMethodError => e
       rescue_no_method_error_with(exception: e)

data/lib/servactory/test_kit/result.rb

@@ -3,16 +3,29 @@
 module Servactory
   module TestKit
     class Result
-      def self.as_success(attributes = {})
+      def self.as_success(**attributes)
+        service_class = attributes.delete(:service_class) || self
+
         context = new(attributes)
 
-        Servactory::Result.success_for(context:)
+        if service_class == Servactory::TestKit::Result
+          Servactory::Result.success_for(context:)
+        else
+          service_class.config.result_class.success_for(context:)
+        end
       end
 
-      def self.as_failure(attributes = {}, exception: nil)
+      def self.as_failure(**attributes)
+        service_class = attributes.delete(:service_class) || self
+        exception = attributes.delete(:exception)
+
         context = new(attributes)
 
-        Servactory::Result.failure_for(context:, exception:)
+        if service_class == Servactory::TestKit::Result
+          Servactory::Result.failure_for(context:, exception:)
+        else
+          service_class.config.result_class.failure_for(context:, exception:)
+        end
       end
 
       def initialize(attributes = {})

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

@@ -64,17 +64,7 @@ module Servactory
                      {}
                    end
 
-          # puts
-          # puts <<~RUBY
-          #   allow(#{service_class}).to(
-          #     receive(#{method_call.inspect})
-          #       .public_send(
-          #         #{and_return_or_raise.inspect},
-          #         Servactory::TestKit::Result.public_send(#{result_type.inspect}, #{result})
-          #       )
-          #   )
-          # RUBY
-          # puts
+          result[:service_class] = service_class
 
           allow(service_class).to(
             receive(method_call)
@@ -92,7 +82,7 @@ module Servactory
                 if as_success || !with_bang
                   Servactory::TestKit::Result.public_send(result_type, **result)
                 else
-                  Servactory::TestKit::Result.public_send(result_type, result)
+                  result.fetch(:exception)
                 end
               )
           )

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

@@ -46,6 +46,8 @@ module Servactory
             def submatcher_passes?(_subject)
               attribute_default_value = attribute_data.fetch(:default)
 
+              return default_value.nil? if attribute_default_value.is_a?(NilClass)
+
               attribute_default_value.to_s.casecmp(default_value.to_s).zero?
             end