servactory 2.3.1 → 2.4.3

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

@@ -52,7 +52,7 @@ module Servactory
             add_error(
               message: message.presence || Servactory::Maintenance::Attributes::Translator::Inclusion.default_message,
               service_class_name: @context.class.name,
-              "#{@attribute.system_name}": @attribute,
+              **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value
             )
           end

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

@@ -28,11 +28,11 @@ module Servactory
 
           def check
             @check_options.each do |code, options|
-              message = call_or_fetch_message_from(code, options)
+              message, reason = call_or_fetch_message_from(code, options)
 
               next if message.blank?
 
-              add_error_with(message, code)
+              add_error_with(message, code, reason)
             end
 
             errors
@@ -40,12 +40,18 @@ module Servactory
 
           private
 
-          def call_or_fetch_message_from(code, options)
+          def call_or_fetch_message_from(code, options) # rubocop:disable Metrics/MethodLength
             check, message = options.values_at(:is, :message)
 
-            return if check.call(value: @value)
+            check_result, check_result_code =
+              check.call(value: @value, **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute))
 
-            message.presence || Servactory::Maintenance::Attributes::Translator::Must.default_message
+            return if check_result
+
+            [
+              message.presence || Servactory::Maintenance::Attributes::Translator::Must.default_message,
+              check_result_code
+            ]
           rescue StandardError => e
             add_syntax_error_with(
               Servactory::Maintenance::Attributes::Translator::Must.syntax_error_message,
@@ -56,13 +62,14 @@ module Servactory
 
           ########################################################################
 
-          def add_error_with(message, code)
+          def add_error_with(message, code, reason)
             add_error(
               message: message,
               service_class_name: @context.class.name,
-              "#{@attribute.system_name}": @attribute,
+              **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value,
-              code: code
+              code: code,
+              reason: reason
             )
           end
 
@@ -70,7 +77,7 @@ module Servactory
             add_error(
               message: message,
               service_class_name: @context.class.name,
-              "#{@attribute.system_name}": @attribute,
+              **Servactory::Utils.fetch_hash_with_desired_attribute(@attribute),
               value: @value,
               code: code,
               exception_message: exception_message

data/lib/servactory/outputs/output.rb

@@ -3,6 +3,25 @@
 module Servactory
   module Outputs
     class Output
+      class Work
+        attr_reader :name,
+                    :types,
+                    :inclusion
+
+        def initialize(output)
+          @name = output.name
+          @types = output.types
+          @inclusion = output.inclusion.slice(:in) if output.inclusion_present?
+
+          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 }
+        end
+      end
+
       attr_reader :name,
                   :collection_of_options
 
@@ -35,7 +54,10 @@ module Servactory
       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: helpers, options: options) if helpers.present?
+        options = apply_helpers_for_options(helpers: advanced_helpers, options: options) if advanced_helpers.present?
 
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
@@ -54,15 +76,22 @@ module Servactory
         @collection_of_options = options_registrar.collection
       end
 
-      def apply_helpers_for_options(helpers:, options:)
+      def apply_helpers_for_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
         prepared_options = {}
 
-        helpers.each do |helper|
+        helpers.each do |(helper, values)|
           found_helper = @option_helpers.find_by(name: helper)
 
           next if found_helper.blank?
 
-          prepared_options.merge!(found_helper.equivalent)
+          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.merge(prepared_options)

data/lib/servactory/result.rb

@@ -9,6 +9,18 @@ module Servactory
           define_singleton_method(key) { value }
         end
       end
+
+      def inspect
+        "#<#{self.class.name} #{draw_result}>"
+      end
+
+      private
+
+      def draw_result
+        methods(false).sort.map do |method_name|
+          "@#{method_name}=#{send(method_name)}"
+        end.join(", ")
+      end
     end
 
     private_constant :Outputs
@@ -19,11 +31,11 @@ module Servactory
       new(context: context).send(:as_success)
     end
 
-    def self.failure_for(exception:)
-      new(exception: exception).send(:as_failure)
+    def self.failure_for(context:, exception:)
+      new(context: context, exception: exception).send(:as_failure)
     end
 
-    def initialize(context: nil, exception: nil)
+    def initialize(context:, exception: nil)
       @context = context
       @exception = exception
     end
@@ -39,7 +51,7 @@ module Servactory
     end
 
     def on_failure(type = :all)
-      yield(exception: @exception) if failure? && [:all, @exception&.type].include?(type)
+      yield(outputs: outputs, exception: @exception) if failure? && [:all, @exception&.type].include?(type)
 
       self
     end
@@ -78,6 +90,10 @@ module Servactory
         false
       end
 
+      outputs.methods(false).each do |method_name|
+        define_singleton_method(method_name) { outputs.send(method_name) }
+      end
+
       self
     end
 
@@ -88,7 +104,7 @@ module Servactory
     end
 
     def outputs
-      @outputs ||= Outputs.new(@context.send(:servactory_service_storage).fetch(:outputs))
+      @outputs ||= Outputs.new(@context.send(:servactory_service_store).outputs)
     end
 
     ########################################################################

data/lib/servactory/test_kit/result.rb

@@ -7,13 +7,13 @@ module Servactory
         Servactory::Result.success_for(context: new(attributes))
       end
 
-      def self.as_failure(exception: nil)
-        Servactory::Result.failure_for(exception: exception)
+      def self.as_failure(attributes = {}, exception: nil)
+        Servactory::Result.failure_for(context: new(attributes), exception: exception)
       end
 
       def initialize(attributes = {})
         attributes.each_pair do |name, value|
-          servactory_service_storage[:outputs].merge!({ name => value })
+          servactory_service_store.assign_output(name, value)
         end
       end
 
@@ -21,8 +21,8 @@ module Servactory
 
       private
 
-      def servactory_service_storage
-        @servactory_service_storage ||= { outputs: {} }
+      def servactory_service_store
+        @servactory_service_store ||= Servactory::Context::Store.new(self)
       end
     end
   end

data/lib/servactory/tool_kit/dynamic_options/format.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Servactory
+  module ToolKit
+    module DynamicOptions
+      class Format < Must
+        DEFAULT_FORMATS = {
+          boolean: {
+            pattern: /^(true|false|0|1)$/i,
+            validator: ->(value:) { %w[true 1].include?(value&.downcase) }
+          },
+          email: {
+            pattern: URI::MailTo::EMAIL_REGEXP,
+            validator: ->(value:) { value.present? }
+          },
+          date: {
+            pattern: nil,
+            validator: lambda do |value:|
+              Date.parse(value) and return true
+            rescue Date::Error
+              false
+            end
+          },
+          datetime: {
+            pattern: nil,
+            validator: lambda do |value:|
+              DateTime.parse(value) and return true
+            rescue Date::Error
+              false
+            end
+          },
+          password: {
+            # NOTE: Pattern 4 » https://dev.to/rasaf_ibrahim/write-regex-password-validation-like-a-pro-5175
+            #       Password must contain one digit from 1 to 9, one lowercase letter, one
+            #       uppercase letter, and one underscore, and it must be 8-16 characters long.
+            #       Usage of any other special character and usage of space is optional.
+            pattern: /^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z]).{8,16}$/,
+            validator: ->(value:) { value.present? }
+          },
+          time: {
+            pattern: nil,
+            validator: lambda do |value:|
+              Time.parse(value) and return true
+            rescue ArgumentError
+              false
+            end
+          }
+        }.freeze
+        private_constant :DEFAULT_FORMATS
+
+        def self.use(option_name = :format, formats: {})
+          instance = new(option_name)
+          instance.assign(formats)
+          instance.must(:be_in_format)
+        end
+
+        def assign(formats = {})
+          @formats = formats.is_a?(Hash) ? DEFAULT_FORMATS.merge(formats) : DEFAULT_FORMATS
+        end
+
+        def condition_for_input_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_internal_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_output_with(...)
+          common_condition_with(...)
+        end
+
+        def common_condition_with(value:, option:, **)
+          option_value = option.value&.to_sym
+
+          return [false, :unknown] unless @formats.key?(option_value)
+
+          format_options = @formats.fetch(option_value)
+
+          format_pattern = option.properties.fetch(:pattern, format_options.fetch(:pattern))
+
+          return [false, :wrong_pattern] if format_pattern.present? && !value.match?(Regexp.compile(format_pattern))
+
+          option.properties.fetch(:validator, format_options.fetch(:validator)).call(value: value)
+        end
+
+        ########################################################################
+
+        def message_for_input_with(service_class_name:, input:, value:, option_value:, reason:, **)
+          i18n_key = "servactory.inputs.validations.must.dynamic_options.format"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          I18n.t(
+            i18n_key,
+            service_class_name: service_class_name,
+            input_name: input.name,
+            value: value,
+            format_name: option_value.present? ? option_value : option_value.inspect
+          )
+        end
+
+        def message_for_internal_with(service_class_name:, internal:, value:, option_value:, reason:, **)
+          i18n_key = "servactory.internals.validations.must.dynamic_options.format"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          I18n.t(
+            i18n_key,
+            service_class_name: service_class_name,
+            internal_name: internal.name,
+            value: value,
+            format_name: option_value.present? ? option_value : option_value.inspect
+          )
+        end
+
+        def message_for_output_with(service_class_name:, output:, value:, option_value:, reason:, **)
+          i18n_key = "servactory.outputs.validations.must.dynamic_options.format"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          I18n.t(
+            i18n_key,
+            service_class_name: service_class_name,
+            output_name: output.name,
+            value: value,
+            format_name: option_value.present? ? option_value : option_value.inspect
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/tool_kit/dynamic_options/max.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Servactory
+  module ToolKit
+    module DynamicOptions
+      class Max < Must
+        def self.use(option_name = :max)
+          new(option_name).must(:be_less_than_or_equal_to)
+        end
+
+        def condition_for_input_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_internal_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_output_with(...)
+          common_condition_with(...)
+        end
+
+        def common_condition_with(value:, option:, **)
+          case value
+          when Integer
+            value <= option.value
+          else
+            return false unless value.respond_to?(:size)
+
+            value.size <= option.value
+          end
+        end
+
+        ########################################################################
+
+        def message_for_input_with(service_class_name:, input:, value:, option_value:, **)
+          I18n.t(
+            "servactory.inputs.validations.must.dynamic_options.max.default",
+            service_class_name: service_class_name,
+            input_name: input.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+
+        def message_for_internal_with(service_class_name:, internal:, value:, option_value:, **)
+          I18n.t(
+            "servactory.internals.validations.must.dynamic_options.max.default",
+            service_class_name: service_class_name,
+            internal_name: internal.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+
+        def message_for_output_with(service_class_name:, output:, value:, option_value:, **)
+          I18n.t(
+            "servactory.outputs.validations.must.dynamic_options.max.default",
+            service_class_name: service_class_name,
+            output_name: output.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/tool_kit/dynamic_options/min.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Servactory
+  module ToolKit
+    module DynamicOptions
+      class Min < Must
+        def self.use(option_name = :min)
+          new(option_name).must(:be_greater_than_or_equal_to)
+        end
+
+        def condition_for_input_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_internal_with(...)
+          common_condition_with(...)
+        end
+
+        def condition_for_output_with(...)
+          common_condition_with(...)
+        end
+
+        def common_condition_with(value:, option:, **)
+          case value
+          when Integer
+            value >= option.value
+          else
+            return false unless value.respond_to?(:size)
+
+            value.size >= option.value
+          end
+        end
+
+        ########################################################################
+
+        def message_for_input_with(service_class_name:, input:, value:, option_value:, **)
+          I18n.t(
+            "servactory.inputs.validations.must.dynamic_options.min.default",
+            service_class_name: service_class_name,
+            input_name: input.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+
+        def message_for_internal_with(service_class_name:, internal:, value:, option_value:, **)
+          I18n.t(
+            "servactory.internals.validations.must.dynamic_options.min.default",
+            service_class_name: service_class_name,
+            internal_name: internal.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+
+        def message_for_output_with(service_class_name:, output:, value:, option_value:, **)
+          I18n.t(
+            "servactory.outputs.validations.must.dynamic_options.min.default",
+            service_class_name: service_class_name,
+            output_name: output.name,
+            value: value,
+            option_value: option_value
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/tool_kit/dynamic_options/must.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Servactory
+  module ToolKit
+    module DynamicOptions
+      class Must
+        class WorkOption
+          attr_reader :value,
+                      :message,
+                      :properties
+
+          def initialize(data, body_key:, body_fallback:)
+            @value =
+              if data.is_a?(Hash) && data.key?(body_key)
+                data.delete(body_key)
+              else
+                data.present? ? data : body_fallback
+              end
+
+            @message = (data.is_a?(Hash) && data.key?(:message) ? data.delete(:message) : nil)
+            @properties = data.is_a?(Hash) ? data : {}
+          end
+        end
+
+        def initialize(option_name, body_key = :is, body_fallback = nil)
+          @option_name = option_name
+          @body_key = body_key
+          @body_fallback = body_fallback
+        end
+
+        def must(name)
+          Servactory::Maintenance::Attributes::OptionHelper.new(
+            name: @option_name,
+            equivalent: equivalent_with(name)
+          )
+        end
+
+        def equivalent_with(name)
+          lambda do |data|
+            option = WorkOption.new(data, body_key: @body_key, body_fallback: @body_fallback)
+
+            {
+              must: {
+                name => must_content_with(option)
+              }
+            }
+          end
+        end
+
+        def must_content_with(option)
+          {
+            is: must_content_value_with(option),
+            message: must_content_message_with(option)
+          }
+        end
+
+        ########################################################################
+
+        def must_content_value_with(option)
+          lambda do |value:, input: nil, internal: nil, output: nil|
+            if input.present? && input.input?
+              condition_for_input_with(input: input, value: value, option: option)
+            elsif internal.present? && internal.internal?
+              condition_for_internal_with(internal: internal, value: value, option: option)
+            elsif output.present? && output.output?
+              condition_for_output_with(output: output, value: value, option: option)
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def must_content_message_with(option)
+          is_option_message_present = option.message.present?
+          is_option_message_proc = option.message.is_a?(Proc) if is_option_message_present
+
+          lambda do |input: nil, internal: nil, output: nil, **attributes|
+            default_attributes = { **attributes, option_value: option.value }
+
+            if Servactory::Utils.really_input?(input)
+              if is_option_message_present
+                is_option_message_proc ? option.message.call(**default_attributes.merge(input: input)) : option.message
+              else
+                message_for_input_with(**default_attributes.merge(input: input))
+              end
+            elsif Servactory::Utils.really_internal?(internal)
+              if is_option_message_present
+                is_option_message_proc ? option.message.call(**default_attributes.merge(internal: internal)) : option.message # rubocop:disable Layout/LineLength
+              else
+                message_for_internal_with(**default_attributes.merge(internal: internal))
+              end
+            elsif Servactory::Utils.really_output?(output)
+              if is_option_message_present
+                is_option_message_proc ? option.message.call(**default_attributes.merge(output: output)) : option.message # rubocop:disable Layout/LineLength
+              else
+                message_for_output_with(**default_attributes.merge(output: output))
+              end
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        ########################################################################
+
+        def condition_for_input_with(**)
+          raise "Need to implement `condition_for_input_with(**attributes)` method"
+        end
+
+        def condition_for_internal_with(**)
+          raise "Need to implement `condition_for_internal_with(**attributes)` method"
+        end
+
+        def condition_for_output_with(**)
+          raise "Need to implement `condition_for_output_with(**attributes)` method"
+        end
+
+        def message_for_input_with(**)
+          raise "Need to implement `message_for_input_with(**attributes)` method"
+        end
+
+        def message_for_internal_with(**)
+          raise "Need to implement `message_for_internal_with(**attributes)` method"
+        end
+
+        def message_for_output_with(**)
+          raise "Need to implement `message_for_output_with(**attributes)` method"
+        end
+      end
+    end
+  end
+end

data/lib/servactory/utils.rb

@@ -4,14 +4,40 @@ module Servactory
   module Utils
     module_function
 
-    def define_attribute_with(input:, internal:, output:)
-      return input if input.present?
-      return internal if internal.present?
-      return output if output.present?
+    def fetch_hash_with_desired_attribute(attribute)
+      return { input: attribute.class::Work.new(attribute) } if really_input?(attribute)
+      return { internal: attribute.class::Work.new(attribute) } if really_internal?(attribute)
+      return { output: attribute.class::Work.new(attribute) } if really_output?(attribute)
+
+      raise ArgumentError, "Failed to define attribute"
+    end
+
+    def define_attribute_with(input: nil, internal: nil, output: nil)
+      return input if really_input?(input)
+      return internal if really_internal?(internal)
+      return output if really_output?(output)
 
       raise ArgumentError, "missing keyword: :input, :internal or :output"
     end
 
+    def really_input?(attribute = nil)
+      return true if attribute.present? && attribute.input?
+
+      false
+    end
+
+    def really_internal?(attribute = nil)
+      return true if attribute.present? && attribute.internal?
+
+      false
+    end
+
+    def really_output?(attribute = nil)
+      return true if attribute.present? && attribute.output?
+
+      false
+    end
+
     FALSE_VALUES = [
       false,
       nil, "",

data/lib/servactory/version.rb

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

data/lib/servactory.rb

@@ -4,6 +4,8 @@ require "zeitwerk"
 
 require "active_support/all"
 
+require "uri"
+
 loader = Zeitwerk::Loader.for_gem
 loader.inflector.inflect(
   "dsl" => "DSL"