dry-schema 1.3.2 → 1.4.2

data/lib/dry/schema/message_compiler.rb

@@ -41,7 +41,7 @@ module Dry
       attr_reader :default_lookup_options
 
       # @api private
-      def initialize(messages, options = EMPTY_HASH)
+      def initialize(messages, **options)
         super
         @options = options
         @default_lookup_options = options[:locale] ? { locale: locale } : EMPTY_HASH
@@ -55,7 +55,7 @@ module Dry
 
         return self if updated_opts.eql?(options)
 
-        self.class.new(messages, updated_opts)
+        self.class.new(messages, **updated_opts)
       end
 
       # @api private
@@ -105,7 +105,7 @@ module Dry
         left, right = node.map { |n| visit(n, opts) }
 
         if [left, right].flatten.map(&:path).uniq.size == 1
-          Message::Or.new(left, right, proc { |k| messages.translate(k, default_lookup_options) })
+          Message::Or.new(left, right, proc { |k| messages.translate(k, **default_lookup_options) })
         elsif right.is_a?(Array)
           right
         else
@@ -116,7 +116,7 @@ module Dry
       # @api private
       def visit_namespace(node, opts)
         ns, rest = node
-        self.class.new(messages.namespaced(ns), options).visit(rest, opts)
+        self.class.new(messages.namespaced(ns), **options).visit(rest, opts)
       end
 
       # @api private
@@ -130,7 +130,8 @@ module Dry
           path: path.last, **tokens, **lookup_options(arg_vals: arg_vals, input: input)
         ).to_h
 
-        template, meta = messages[predicate, options] || raise(MissingMessageError, path)
+        template, meta = messages[predicate, options] ||
+          raise(MissingMessageError.new(path, messages.looked_up_paths(predicate, options)))
 
         text = message_text(template, tokens, options)
 

data/lib/dry/schema/messages/abstract.rb

@@ -92,45 +92,49 @@ module Dry
         #
         # @api public
         def call(predicate, options)
-          cache.fetch_or_store([predicate, options.reject { |k,| k.equal?(:input) }]) do
+          cache.fetch_or_store(cache_key(predicate, options)) do
             text, meta = lookup(predicate, options)
             [Template[text], meta] if text
           end
         end
         alias_method :[], :call
 
+        # Retrieve an array of looked up paths
+        #
+        # @param [Symbol] predicate
+        # @param [Hash] options
+        #
+        # @return [String]
+        #
+        # @api public
+        def looked_up_paths(predicate, options)
+          tokens = lookup_tokens(predicate, options)
+          filled_lookup_paths(tokens)
+        end
+
         # Try to find a message for the given predicate and its options
         #
         # @api private
         #
         # rubocop:disable Metrics/AbcSize
         def lookup(predicate, options)
-          tokens = options.merge(
-            predicate: predicate,
-            root: options[:not] ? "#{root}.not" : root,
-            arg_type: config.arg_types[options[:arg_type]],
-            val_type: config.val_types[options[:val_type]],
-            message_type: options[:message_type] || :failure
-          )
-
           opts = options.reject { |k, _| config.lookup_options.include?(k) }
-
-          path = lookup_paths(tokens).detect { |key| key?(key, opts) }
+          path = lookup_paths(predicate, options).detect { |key| key?(key, opts) }
 
           return unless path
 
-          text = get(path, opts)
-
-          if text.is_a?(Hash)
-            text.values_at(:text, :meta)
-          else
-            [text, EMPTY_HASH]
-          end
+          get(path, opts).values_at(:text, :meta)
         end
         # rubocop:enable Metrics/AbcSize
 
         # @api private
-        def lookup_paths(tokens)
+        def lookup_paths(predicate, options)
+          tokens = lookup_tokens(predicate, options)
+          filled_lookup_paths(tokens)
+        end
+
+        # @api private
+        def filled_lookup_paths(tokens)
           config.lookup_paths.map { |path| path % tokens }
         end
 
@@ -167,8 +171,28 @@ module Dry
           config.default_locale
         end
 
+        # @api private
+        def cache_key(predicate, options)
+          if options.key?(:input)
+            [predicate, options.reject { |k,| k.equal?(:input) }]
+          else
+            [predicate, options]
+          end
+        end
+
         private
 
+        # @api private
+        def lookup_tokens(predicate, options)
+          options.merge(
+            predicate: predicate,
+            root: options[:not] ? "#{root}.not" : root,
+            arg_type: config.arg_types[options[:arg_type]],
+            val_type: config.val_types[options[:val_type]],
+            message_type: options[:message_type] || :failure
+          )
+        end
+
         # @api private
         def custom_top_namespace?(path)
           path.to_s == DEFAULT_MESSAGES_PATH.to_s && config.top_namespace != DEFAULT_MESSAGES_ROOT

data/lib/dry/schema/messages/i18n.rb

@@ -29,7 +29,24 @@ module Dry
       #
       # @api public
       def get(key, options = EMPTY_HASH)
-        t.(key, locale: options.fetch(:locale, default_locale)) if key
+        return unless key
+
+        opts = { locale: options.fetch(:locale, default_locale) }
+
+        translation = t.(key, opts)
+        text_key = "#{key}.text"
+
+        if !translation.is_a?(Hash) || !key?(text_key, opts)
+          return {
+            text: translation,
+            meta: EMPTY_HASH
+          }
+        end
+
+        {
+          text: t.(text_key, opts),
+          meta: extract_meta(key, translation, opts)
+        }
       end
 
       # Check if given key is defined
@@ -79,6 +96,15 @@ module Dry
         self
       end
 
+      # @api private
+      def cache_key(predicate, options)
+        if options[:locale]
+          super
+        else
+          [*super, I18n.locale]
+        end
+      end
+
       private
 
       # @api private
@@ -91,6 +117,13 @@ module Dry
           I18n.backend.store_translations(locale, data[locale.to_s])
         end
       end
+
+      def extract_meta(parent_key, translation, options)
+        translation.keys.each_with_object({}) do |k, meta|
+          meta_key = "#{parent_key}.#{k}"
+          meta[k] = t.(meta_key, options) if k != :text && key?(meta_key, options)
+        end
+      end
     end
   end
 end

data/lib/dry/schema/messages/namespaced.rb

@@ -55,7 +55,7 @@ module Dry
         end
 
         # @api private
-        def lookup_paths(tokens)
+        def filled_lookup_paths(tokens)
           super(tokens.merge(root: "#{tokens[:root]}.#{namespace}")) + super
         end
 
@@ -64,6 +64,11 @@ module Dry
           base_paths = messages.rule_lookup_paths(tokens)
           base_paths.map { |key| key.gsub('dry_schema', "dry_schema.#{namespace}") } + base_paths
         end
+
+        # @api private
+        def cache_key(predicate, options)
+          messages.cache_key(predicate, options)
+        end
       end
     end
   end

data/lib/dry/schema/messages/template.rb

@@ -59,7 +59,7 @@ module Dry
 
         # @api private
         def call(data = EMPTY_HASH)
-          data.empty? ? evaluator.() : evaluator.(data)
+          data.empty? ? evaluator.() : evaluator.(**data)
         end
         alias_method :[], :call
       end

data/lib/dry/schema/messages/yaml.rb

@@ -68,6 +68,18 @@ module Dry
         @t = proc { |key, locale: default_locale| get("%<locale>s.#{key}", locale: locale) }
       end
 
+      # Get an array of looked up paths
+      #
+      # @param [Symbol] predicate
+      # @param [Hash] options
+      #
+      # @return [String]
+      #
+      # @api public
+      def looked_up_paths(predicate, options)
+        super.map { |path| path % { locale: options[:locale] || default_locale } }
+      end
+
       # Get a message for the given key and its options
       #
       # @param [Symbol] key

data/lib/dry/schema/namespaced_rule.rb

@@ -29,9 +29,10 @@ module Dry
       end
 
       # @api private
-      def ast(input=Undefined)
+      def ast(input = Undefined)
         [:namespace, [namespace, rule.ast(input)]]
       end
+      alias_method :to_ast, :ast
     end
   end
 end

data/lib/dry/schema/predicate_registry.rb

@@ -1,35 +1,14 @@
 # frozen_string_literal: true
 
 require 'dry/logic/predicates'
+require 'dry/types/predicate_registry'
 
 module Dry
   module Schema
     # A registry with predicate objects from `Dry::Logic::Predicates`
     #
     # @api private
-    class PredicateRegistry
-      # @api private
-      attr_reader :predicates
-
-      # @api private
-      attr_reader :has_predicate
-
-      # @api private
-      def initialize(predicates = Dry::Logic::Predicates)
-        @predicates = predicates
-        @has_predicate = ::Kernel.instance_method(:respond_to?).bind(@predicates)
-      end
-
-      # @api private
-      def [](name)
-        predicates[name]
-      end
-
-      # @api private
-      def key?(name)
-        has_predicate.(name)
-      end
-
+    class PredicateRegistry < Dry::Types::PredicateRegistry
       # @api private
       def arg_list(name, *values)
         predicate = self[name]

data/lib/dry/schema/processor.rb

@@ -5,6 +5,7 @@ require 'dry/initializer'
 
 require 'dry/schema/type_registry'
 require 'dry/schema/type_container'
+require 'dry/schema/processor_steps'
 require 'dry/schema/rule_applier'
 require 'dry/schema/key_coercer'
 require 'dry/schema/value_coercer'
@@ -12,14 +13,9 @@ require 'dry/schema/value_coercer'
 module Dry
   module Schema
     # Processes input data using objects configured within the DSL
+    # Processing is split into steps represented by `ProcessorSteps`.
     #
-    # Processing is split into 4 main steps:
-    #
-    #   1. Prepare input hash using a key map
-    #   2. Apply pre-coercion filtering rules (optional step, used only when `filter` was used)
-    #   3. Apply value coercions based on type specifications
-    #   4. Apply rules
-    #
+    # @see ProcessorSteps
     # @see Params
     # @see JSON
     #
@@ -29,10 +25,10 @@ module Dry
       extend Dry::Configurable
 
       setting :key_map_type
-      setting :type_registry_namespace, :nominal
+      setting :type_registry_namespace, :strict
       setting :filter_empty_string, false
 
-      option :steps, default: -> { EMPTY_ARRAY.dup }
+      option :steps, default: -> { ProcessorSteps.new }
 
       option :schema_dsl
 
@@ -66,7 +62,7 @@ module Dry
         # @api public
         def new(options = nil, &block)
           if options || block
-            processor = super
+            processor = super(**(options || EMPTY_HASH))
             yield(processor) if block
             processor
           elsif definition
@@ -77,16 +73,6 @@ module Dry
         end
       end
 
-      # Append a step
-      #
-      # @return [Processor]
-      #
-      # @api private
-      def <<(step)
-        steps << step
-        self
-      end
-
       # Apply processing steps to the provided input
       #
       # @param [Hash] input
@@ -96,10 +82,7 @@ module Dry
       # @api public
       def call(input)
         Result.new(input, message_compiler: message_compiler) do |result|
-          steps.each do |step|
-            output = step.(result)
-            result.replace(output) if output.is_a?(::Hash)
-          end
+          steps.call(result)
         end
       end
       alias_method :[], :call
@@ -119,7 +102,7 @@ module Dry
       #
       # @api public
       def key_map
-        @key_map ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+        steps[:key_coercer].key_map
       end
 
       # Return string represntation
@@ -139,7 +122,7 @@ module Dry
       #
       # @api private
       def type_schema
-        @type_schema ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+        steps[:value_coercer].type_schema
       end
 
       # Return the rules config
@@ -180,7 +163,7 @@ module Dry
       #
       # @api private
       def rule_applier
-        @rule_applier ||= steps.last
+        steps[:rule_applier]
       end
       alias_method :to_rule, :rule_applier
 

data/lib/dry/schema/processor_steps.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'dry/initializer'
+
+module Dry
+  module Schema
+    # Steps for the Dry::Schema::Processor
+    #
+    # There are 4 main steps:
+    #
+    #   1. `key_coercer` - Prepare input hash using a key map
+    #   2. `filter_schema` - Apply pre-coercion filtering rules
+    #      (optional step, used only when `filter` was used)
+    #   3. `value_coercer` - Apply value coercions based on type specifications
+    #   4. `rule_applier` - Apply rules
+    #
+    # @see Processor
+    #
+    # @api public
+    class ProcessorSteps
+      extend Dry::Initializer
+
+      STEPS_IN_ORDER = %i[key_coercer filter_schema value_coercer rule_applier].freeze
+
+      option :steps, default: -> { EMPTY_HASH.dup }
+      option :before_steps, default: -> { EMPTY_HASH.dup }
+      option :after_steps, default: -> { EMPTY_HASH.dup }
+
+      # Executes steps and callbacks in order
+      #
+      # @param [Result] result
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(result)
+        STEPS_IN_ORDER.each do |name|
+          before_steps[name]&.each { |step| process_step(step, result) }
+          process_step(steps[name], result)
+          after_steps[name]&.each { |step| process_step(step, result) }
+        end
+        result
+      end
+
+      # Returns step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def [](name)
+        steps[name]
+      end
+
+      # Sets step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def []=(name, value)
+        validate_step_name(name)
+        steps[name] = value
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def after(name, &block)
+        validate_step_name(name)
+        after_steps[name] ||= EMPTY_ARRAY.dup
+        after_steps[name] << block.to_proc
+        self
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def before(name, &block)
+        validate_step_name(name)
+        before_steps[name] ||= EMPTY_ARRAY.dup
+        before_steps[name] << block.to_proc
+        self
+      end
+
+      # @api private
+      def process_step(step, result)
+        return unless step
+
+        output = step.(result)
+        result.replace(output) if output.is_a?(::Hash)
+      end
+
+      # @api private
+      def validate_step_name(name)
+        return if STEPS_IN_ORDER.include?(name)
+
+        raise ArgumentError, "Undefined step name #{name}. Available names: #{STEPS_IN_ORDER}"
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @steps = source.steps.dup
+        @before_steps = source.before_steps.dup
+        @after_steps = source.after_steps.dup
+      end
+    end
+  end
+end