dry-validation 0.6.0 → 0.7.0

data/lib/dry/validation/error.rb

@@ -1,39 +1,23 @@
 module Dry
   module Validation
     class Error
-      class Set
-        include Enumerable
+      include Dry::Equalizer(:name, :result)
 
-        attr_reader :errors
+      attr_reader :name, :result
 
-        def initialize(errors)
-          @errors = errors
-        end
-
-        def each(&block)
-          errors.each(&block)
-        end
-
-        def empty?
-          errors.empty?
-        end
-
-        def to_ary
-          errors.map { |error| error.to_ary }
-        end
-        alias_method :to_a, :to_ary
+      def initialize(name, result)
+        @name = name
+        @result = result
       end
 
-      attr_reader :result
-
-      def initialize(result)
-        @result = result
+      def schema?
+        result.response.is_a?(Validation::Result)
       end
 
-      def to_ary
-        [:error, result.to_ary]
+      def to_ast
+        node = [:error, [name, result.to_ast]]
+        schema? ? [:schema, node] : node
       end
-      alias_method :to_a, :to_ary
     end
   end
 end

data/lib/dry/validation/error_compiler.rb

@@ -1,18 +1,25 @@
 module Dry
   module Validation
     class ErrorCompiler
-      attr_reader :messages, :options
+      attr_reader :messages, :hints, :options
 
       DEFAULT_RESULT = {}.freeze
+      EMPTY_HINTS = [].freeze
       KEY_SEPARATOR = '.'.freeze
 
       def initialize(messages, options = {})
         @messages = messages
-        @options = options
+        @options = Hash[options]
+        @hints = @options.fetch(:hints, {})
+        @full = options.fetch(:full, false)
       end
 
-      def call(ast)
-        merge(ast.map { |node| visit(node) }) || DEFAULT_RESULT
+      def full?
+        @full
+      end
+
+      def call(ast, *args)
+        merge(ast.map { |node| visit(node, *args) }) || DEFAULT_RESULT
       end
 
       def with(new_options)
@@ -23,135 +30,98 @@ module Dry
         __send__(:"visit_#{node[0]}", node[1], *args)
       end
 
-      def visit_error(error)
-        visit(error)
-      end
-
-      def visit_input(input, *)
-        name = normalize_name(input[0])
-        _, value, rules = input
-        errors = [rules.map { |rule| visit(rule, name, value) }, value]
-
-        if input[0].is_a?(Hash)
-          root, sub = input[0].to_a.flatten
-          { root => { sub => errors } }
-        else
-          { input[0] => errors }
-        end
-      end
-
-      def visit_group(_, name, _)
-        messages[name, rule: name]
-      end
-
-      def visit_check(node, *)
-        name = normalize_name(node[0])
-        messages[name, rule: name]
-      end
-
-      def visit_key(rule, name, value)
-        _, predicate = rule
-        visit(predicate, value, name)
-      end
-
-      def visit_attr(rule, name, value)
-        _, predicate = rule
-        visit(predicate, value, name)
-      end
-
-      def visit_val(rule, name, value)
-        name, predicate = rule
-        visit(predicate, value, name)
-      end
-
-      def visit_predicate(predicate, value, name)
-        predicate_name, args = predicate
-
-        lookup_options = options.merge(
-          rule: name, val_type: value.class, arg_type: args[0].class
-        )
-
-        template = messages[predicate_name, lookup_options]
-        tokens = visit(predicate, value).merge(name: name)
-
-        template % tokens
+      def visit_schema(node, *args)
+        visit_error(node[1], true)
       end
 
-      def visit_key?(*args, _value)
-        { name: args[0][0] }
+      def visit_set(node, *args)
+        call(node, *args)
       end
 
-      def visit_attr?(*args, _value)
-        { name: args[0][0] }
-      end
-
-      def visit_exclusion?(*args, _value)
-        { list: args[0][0].join(', ') }
-      end
+      def visit_error(error, schema = false)
+        name, other = error
+        message = messages[name]
 
-      def visit_inclusion?(*args, _value)
-        { list: args[0][0].join(', ') }
-      end
+        if message
+          { name => [message] }
+        else
+          result = schema ? visit(other, name) : visit(other)
 
-      def visit_gt?(*args, value)
-        { num: args[0][0], value: value }
+          if result.is_a?(Array)
+            merge(result)
+          else
+            merge_hints(result)
+          end
+        end
       end
 
-      def visit_gteq?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_input(node, path = nil)
+        name, result = node
+        visit(result, path || name)
       end
 
-      def visit_lt?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_result(node, name = nil)
+        value, other = node
+        input_visitor(name, value).visit(other)
       end
 
-      def visit_lteq?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_implication(node)
+        _, right = node
+        visit(right)
       end
 
-      def visit_int?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_key(rule)
+        _, predicate = rule
+        visit(predicate)
       end
 
-      def visit_max_size?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_attr(rule)
+        _, predicate = rule
+        visit(predicate)
       end
 
-      def visit_min_size?(*args, value)
-        { num: args[0][0], value: value }
+      def visit_val(node)
+        visit(node)
       end
 
-      def visit_eql?(*args, value)
-        { eql_value: args[0][0], value: value }
-      end
+      private
 
-      def visit_size?(*args, value)
-        num = args[0][0]
+      def merge_hints(messages)
+        messages.each_with_object({}) do |(name, msgs), res|
+          if msgs.is_a?(Hash)
+            res[name] = merge_hints(msgs)
+          else
+            all_msgs = msgs + (hints[name] || EMPTY_HINTS)
+            all_msgs.uniq!
 
-        if num.is_a?(Range)
-          { left: num.first, right: num.last, value: value }
-        else
-          { num: args[0][0], value: value }
+            res[name] = all_msgs
+          end
         end
       end
 
-      private
-
       def normalize_name(name)
-        Array(name).join(KEY_SEPARATOR).to_sym
+        Array(name).join('.').to_sym
       end
 
       def merge(result)
-        result.reduce do |a, e|
-          e.merge(a) do |_, l, r|
-            l.is_a?(Hash) ? l.merge(r) : l + r
+        result.reduce { |a, e| deep_merge(a, e) } || DEFAULT_RESULT
+      end
+
+      def deep_merge(left, right)
+        left.merge(right) do |_, a, e|
+          if a.is_a?(Hash)
+            deep_merge(a, e)
+          else
+            a + e
           end
         end
       end
 
-      def method_missing(_meth, *args)
-        { value: args[1] }
+      def input_visitor(name, input)
+        Input.new(messages, options.merge(name: name, input: input))
       end
     end
   end
 end
+
+require 'dry/validation/error_compiler/input'

data/lib/dry/validation/error_compiler/input.rb

@@ -0,0 +1,148 @@
+module Dry
+  module Validation
+    class ErrorCompiler::Input < ErrorCompiler
+      attr_reader :name, :input, :rule, :val_type
+
+      def initialize(messages, options)
+        super
+        @name = options.fetch(:name)
+        @input = options.fetch(:input)
+        @rule = Array(name).last
+        @val_type = input.class
+      end
+
+      def visit_each(node)
+        node.map { |el| visit(el) }
+      end
+
+      def visit_set(node)
+        result = node.map do |input|
+          visit(input)
+        end
+        merge(result)
+      end
+
+      def visit_el(node)
+        idx, el = node
+        name = [*Array(name), idx]
+        visit(el, name)
+      end
+
+      def visit_check(node)
+        _, other = node
+        visit(other)
+      end
+
+      def visit_predicate(node)
+        predicate, args = node
+
+        lookup_options = options.merge(
+          rule: rule, val_type: val_type, arg_type: args[0].class
+        )
+
+        tokens = options_for(predicate, args)
+        template = messages[predicate, lookup_options.merge(tokens)]
+
+        unless template
+          raise MissingMessageError.new("message for #{predicate} was not found")
+        end
+
+        rule_name =
+          if rule.is_a?(Symbol)
+            messages.rule(rule, lookup_options) || rule
+          else
+            rule
+          end
+
+        message =
+          if full?
+            "#{rule_name} #{template % tokens}"
+          else
+            template % tokens
+          end
+
+        path = [[message], *[tokens[:name], *Array(name).reverse].uniq]
+
+        path.reduce { |a, e| { e => a } }
+      end
+
+      def options_for_type?(*args)
+        { type: args[0][0] }
+      end
+
+      def options_for_key?(*args)
+        { name: args[0][0] }
+      end
+
+      def options_for_attr?(*args)
+        { name: args[0][0] }
+      end
+
+      def options_for_exclusion?(*args)
+        { list: args[0][0].join(', ') }
+      end
+
+      def options_for_inclusion?(*args)
+        { list: args[0][0].join(', ') }
+      end
+
+      def options_for_gt?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_gteq?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_lt?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_lteq?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_int?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_max_size?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_min_size?(*args)
+        { num: args[0][0], value: input }
+      end
+
+      def options_for_eql?(*args)
+        { eql_value: args[0][0], value: input }
+      end
+
+      def options_for_size?(*args)
+        num = args[0][0]
+
+        if num.is_a?(Range)
+          { left: num.first, right: num.last, value: input }
+        else
+          { num: args[0][0], value: input }
+        end
+      end
+
+      def options_for(predicate, args)
+        meth = :"options_for_#{predicate}"
+
+        defaults = { name: rule, rule: rule, value: input }
+
+        if respond_to?(meth)
+          defaults.merge!(__send__(meth, args))
+        end
+
+        defaults
+      end
+
+      def input_visitor(new_name, value)
+        self.class.new(messages, options.merge(name: [*name, *new_name].uniq, input: value))
+      end
+    end
+  end
+end

data/lib/dry/validation/hint_compiler.rb

@@ -1,14 +1,37 @@
-require 'dry/validation/error_compiler'
+require 'dry/validation/error_compiler/input'
 
 module Dry
   module Validation
-    class HintCompiler < ErrorCompiler
-      attr_reader :messages, :rules, :options
+    class HintCompiler < ErrorCompiler::Input
+      include Dry::Equalizer(:messages, :rules, :options)
+
+      attr_reader :rules, :excluded
+
+      TYPES = {
+        none?: NilClass,
+        bool?: TrueClass,
+        str?: String,
+        int?: Fixnum,
+        float?: Float,
+        decimal?: BigDecimal,
+        date?: Date,
+        date_time?: DateTime,
+        time?: Time,
+        hash?: Hash,
+        array?: Array
+      }.freeze
+
+      EXCLUDED = [:none?, :filled?, :key?].freeze
+
+      def self.cache
+        @cache ||= ThreadSafe::Cache.new
+      end
 
       def initialize(messages, options = {})
-        @messages = messages
-        @options = Hash[options]
+        super(messages, { name: nil, input: nil }.merge(options))
         @rules = @options.delete(:rules)
+        @excluded = @options.fetch(:excluded, EXCLUDED)
+        @val_type = options[:val_type]
       end
 
       def with(new_options)
@@ -16,58 +39,85 @@ module Dry
       end
 
       def call
-        messages = Hash.new { |h, k| h[k] = [] }
+        self.class.cache.fetch_or_store(hash) do
+          super(rules)
+        end
+      end
+
+      def visit_predicate(node)
+        predicate, _ = node
+
+        val_type = TYPES[predicate]
+
+        return with(val_type: val_type) if val_type
+        return {} if excluded.include?(predicate)
 
-        rules.map { |node| visit(node) }.compact.each do |hints|
-          name, msgs = hints
-          messages[name].concat(msgs)
+        super
+      end
+
+      def visit_set(node)
+        result = node.map do |el|
+          visit(el)
         end
+        merge(result)
+      end
 
-        messages
+      def visit_each(node)
+        visit(node)
       end
 
       def visit_or(node)
         left, right = node
-        [visit(left), Array(visit(right)).flatten.compact].compact
+        merge([visit(left), visit(right)])
       end
 
       def visit_and(node)
         left, right = node
-        [visit(left), Array(visit(right)).flatten.compact].compact
-      end
 
-      def visit_val(node)
-        name, predicate = node
-        visit(predicate, name)
-      end
+        result = visit(left)
 
-      def visit_predicate(node, name)
-        predicate_name, args = node
+        if result.is_a?(self.class)
+          result.visit(right)
+        else
+          visit(right)
+        end
+      end
 
-        lookup_options = options.merge(rule: name, arg_type: args[0].class)
+      def visit_implication(node)
+        _, right = node
+        visit(right)
+      end
 
-        template = messages[predicate_name, lookup_options]
-        predicate_opts = visit(node, args)
+      def visit_key(node)
+        name, predicate = node
+        with(name: Array([*self.name, name])).visit(predicate)
+      end
+      alias_method :visit_attr, :visit_key
 
-        return unless predicate_opts
+      def visit_val(node)
+        visit(node)
+      end
 
-        tokens = predicate_opts.merge(name: name)
+      def visit_schema(node)
+        DEFAULT_RESULT
+      end
 
-        template % tokens
+      def visit_check(node)
+        DEFAULT_RESULT
       end
 
-      def visit_key(node)
-        name, _ = node
-        name
+      def visit_xor(node)
+        DEFAULT_RESULT
       end
 
-      def visit_attr(node)
-        name, _ = node
-        name
+      def visit_not(node)
+        DEFAULT_RESULT
       end
 
-      def method_missing(name, *args)
-        nil
+      private
+
+      def merge(result)
+        super(result.reject { |el| el.is_a?(self.class) })
       end
     end
   end