dry-schema 1.2.0 → 1.4.1

data/lib/dry/schema/message.rb

@@ -60,7 +60,7 @@ module Dry
       #
       # If a string is passed, it will be compared with the text
       #
-      # @param [Message,String]
+      # @param other [Message,String]
       #
       # @return [Boolean]
       #

data/lib/dry/schema/message_compiler.rb

@@ -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,30 +92,34 @@ 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
 
@@ -130,7 +134,13 @@ module Dry
         # 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 +177,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

@@ -79,6 +79,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

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/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/path.rb

@@ -65,8 +65,10 @@ module Dry
       # @api private
       def include?(other)
         return false unless same_root?(other)
-        return false if index? && other.index? && !last.equal?(other.last)
-        self >= other
+        return last.equal?(other.last) if index? && other.index?
+        return self.class.new([*to_a[0..-2]]).include?(other) if index?
+
+        self >= other && !other.key_matches(self).include?(nil)
       end
 
       # @api private
@@ -75,14 +77,16 @@ module Dry
 
         return 0 if keys.eql?(other.keys)
 
-        res =
-          map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
-            .compact
-            .reject { |value| value.equal?(false) }
+        res = key_matches(other).compact.reject { |value| value.equal?(false) }
 
         res.size < count ? 1 : -1
       end
 
+      # @api private
+      def key_matches(other)
+        map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+      end
+
       # @api private
       def last
         keys.last

data/lib/dry/schema/predicate_inferrer.rb

@@ -22,9 +22,15 @@ module Dry
       }.freeze
 
       REDUCED_TYPES = {
-        %i[true? false?] => :bool?
+        [[[:true?], [:false?]]] => %i[bool?]
       }.freeze
 
+      HASH = %i[hash?].freeze
+
+      ARRAY = %i[array?].freeze
+
+      NIL = %i[nil?].freeze
+
       # Compiler reduces type AST into a list of predicates
       #
       # @api private
@@ -40,7 +46,7 @@ module Dry
 
         # @api private
         def infer_predicate(type)
-          TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }
+          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
         end
 
         # @api private
@@ -54,21 +60,21 @@ module Dry
           type = node[0]
           predicate = infer_predicate(type)
 
-          if registry.key?(predicate)
+          if registry.key?(predicate[0])
             predicate
           else
-            { type?: type }
+            [type?: type]
           end
         end
 
         # @api private
         def visit_hash(_)
-          :hash?
+          HASH
         end
 
         # @api private
         def visit_array(_)
-          :array?
+          ARRAY
         end
 
         # @api private
@@ -90,26 +96,73 @@ module Dry
 
         # @api private
         def visit_sum(node)
-          left, right = node
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
 
-          predicates = [visit(left), visit(right)]
-
-          if predicates.first == :nil?
-            predicates[1..predicates.size - 1]
+          if left.eql?(NIL)
+            right
           else
-            predicates
+            [[left, right]]
           end
         end
 
         # @api private
         def visit_constrained(node)
-          other, * = node
-          visit(other)
+          other, rules = node
+          predicates = visit(rules)
+
+          if predicates.empty?
+            visit(other)
+          else
+            [*visit(other), *merge_predicates(predicates)]
+          end
         end
 
         # @api private
         def visit_any(_)
-          nil
+          EMPTY_ARRAY
+        end
+
+        # @api private
+        def visit_and(node)
+          left, right = node
+          visit(left) + visit(right)
+        end
+
+        # @api private
+        def visit_predicate(node)
+          pred, args = node
+
+          if pred.equal?(:type?)
+            EMPTY_ARRAY
+          elsif registry.key?(pred)
+            *curried, _ = args
+            values = curried.map { |_, v| v }
+
+            if values.empty?
+              [pred]
+            else
+              [pred => values[0]]
+            end
+          else
+            EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_predicates(nodes)
+          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
+            if predicate.is_a?(::Hash)
+              h.update(predicate)
+            else
+              ps << predicate
+            end
+          end
+
+          merged.empty? ? preds : [*preds, merged]
         end
       end
 
@@ -134,7 +187,7 @@ module Dry
           if predicates.is_a?(Hash)
             predicates
           else
-            Array(REDUCED_TYPES[predicates] || predicates).flatten
+            REDUCED_TYPES[predicates] || predicates
           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
 
@@ -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