dry-validation 0.3.1 → 0.4.0

data/lib/dry/validation/error_compiler.rb

@@ -14,8 +14,8 @@ module Dry
         ast.map { |node| visit(node) }.reduce(:merge) || DEFAULT_RESULT
       end
 
-      def with(options)
-        self.class.new(messages, options)
+      def with(new_options)
+        self.class.new(messages, options.merge(new_options))
       end
 
       def visit(node, *args)
@@ -28,7 +28,12 @@ module Dry
 
       def visit_input(input, *args)
         name, value, rules = input
-        { name => rules.map { |rule| visit(rule, name, value) } }
+        { name => [rules.map { |rule| visit(rule, name, value) }, value] }
+      end
+
+      def visit_check(node, *args)
+        name, _ = node
+        messages[name, rule: name]
       end
 
       def visit_key(rule, name, value)
@@ -51,7 +56,7 @@ module Dry
         template = messages[predicate_name, lookup_options]
         tokens = visit(predicate, value).merge(name: name)
 
-        [template % tokens, value]
+        template % tokens
       end
 
       def visit_key?(*args, value)

data/lib/dry/validation/hint_compiler.rb

@@ -0,0 +1,69 @@
+require 'dry/validation/error_compiler'
+
+module Dry
+  module Validation
+    class HintCompiler < ErrorCompiler
+      attr_reader :messages, :rules, :options
+
+      def initialize(messages, options = {})
+        @messages = messages
+        @options = Hash[options]
+        @rules = @options.delete(:rules)
+      end
+
+      def with(new_options)
+        super(new_options.merge(rules: rules))
+      end
+
+      def call
+        messages = Hash.new { |h, k| h[k] = [] }
+
+        rules.map { |node| visit(node) }.compact.each do |hints|
+          name, msgs = hints
+          messages[name].concat(msgs)
+        end
+
+        messages
+      end
+
+      def visit_or(node)
+        left, right = node
+        [visit(left), Array(visit(right)).flatten.compact].compact
+      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
+
+      def visit_predicate(node, name)
+        predicate_name, args = node
+
+        lookup_options = options.merge(rule: name, arg_type: args[0].class)
+
+        template = messages[predicate_name, lookup_options]
+        predicate_opts = visit(node, args)
+
+        return unless predicate_opts
+
+        tokens = predicate_opts.merge(name: name)
+
+        template % tokens
+      end
+
+      def visit_key(node)
+        name, _ = node
+        name
+      end
+
+      def method_missing(name, *args)
+        nil
+      end
+    end
+  end
+end

data/lib/dry/validation/predicate.rb

@@ -22,10 +22,6 @@ module Dry
         fn.(*args)
       end
 
-      def negation
-        self.class.new(:"not_#{id}") { |input| !fn.(input) }
-      end
-
       def curry(*args)
         self.class.new(id, *args, &fn.curry.(*args))
       end

data/lib/dry/validation/result.rb

@@ -13,6 +13,14 @@ module Dry
         rule_results.each(&block)
       end
 
+      def to_h
+        each_with_object({}) { |result, hash| hash[result.name] = result }
+      end
+
+      def merge!(other)
+        rule_results.concat(other.rule_results)
+      end
+
       def to_ary
         failures.map(&:to_ary)
       end

data/lib/dry/validation/rule.rb

@@ -5,11 +5,41 @@ module Dry
 
       attr_reader :name, :predicate
 
+      class Negation < Rule
+        include Dry::Equalizer(:rule)
+
+        attr_reader :rule
+
+        def initialize(rule)
+          @rule = rule
+        end
+
+        def call(*args)
+          rule.(*args).negated
+        end
+
+        def to_ary
+          [:not, rule.to_ary]
+        end
+      end
+
       def initialize(name, predicate)
         @name = name
         @predicate = predicate
       end
 
+      def predicate_id
+        predicate.id
+      end
+
+      def type
+        :rule
+      end
+
+      def call(*args)
+        Validation.Result(args, predicate.call, self)
+      end
+
       def to_ary
         [type, [name, predicate.to_ary]]
       end
@@ -25,11 +55,24 @@ module Dry
       end
       alias_method :|, :or
 
+      def xor(other)
+        ExclusiveDisjunction.new(self, other)
+      end
+      alias_method :^, :xor
+
       def then(other)
         Implication.new(self, other)
       end
       alias_method :>, :then
 
+      def negation
+        Negation.new(self)
+      end
+
+      def new(predicate)
+        self.class.new(name, predicate)
+      end
+
       def curry(*args)
         self.class.new(name, predicate.curry(*args))
       end
@@ -42,5 +85,6 @@ require 'dry/validation/rule/value'
 require 'dry/validation/rule/each'
 require 'dry/validation/rule/set'
 require 'dry/validation/rule/composite'
+require 'dry/validation/rule/check'
 require 'dry/validation/rule/group'
 require 'dry/validation/rule/result'

data/lib/dry/validation/rule/check.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Validation
+    class Rule::Check < Rule
+      alias_method :result, :predicate
+
+      def call(*)
+        Validation.Result(nil, result.call, self)
+      end
+
+      def type
+        :check
+      end
+    end
+  end
+end

data/lib/dry/validation/rule/composite.rb

@@ -6,11 +6,14 @@ module Dry
       attr_reader :name, :left, :right
 
       def initialize(left, right)
-        @name = left.name
         @left = left
         @right = right
       end
 
+      def name
+        :"#{left.name}_#{type}_#{right.name}"
+      end
+
       def to_ary
         [type, [left.to_ary, right.to_ary]]
       end
@@ -18,8 +21,8 @@ module Dry
     end
 
     class Rule::Implication < Rule::Composite
-      def call(input)
-        left.(input) > right
+      def call(*args)
+        left.(*args) > right
       end
 
       def type
@@ -28,8 +31,8 @@ module Dry
     end
 
     class Rule::Conjunction < Rule::Composite
-      def call(input)
-        left.(input).and(right)
+      def call(*args)
+        left.(*args).and(right)
       end
 
       def type
@@ -38,13 +41,23 @@ module Dry
     end
 
     class Rule::Disjunction < Rule::Composite
-      def call(input)
-        left.(input).or(right)
+      def call(*args)
+        left.(*args).or(right)
       end
 
       def type
         :or
       end
     end
+
+    class Rule::ExclusiveDisjunction < Rule::Composite
+      def call(*args)
+        left.(*args).xor(right)
+      end
+
+      def type
+        :xor
+      end
+    end
   end
 end

data/lib/dry/validation/rule/result.rb

@@ -2,6 +2,7 @@ module Dry
   module Validation
     def self.Result(input, value, rule)
       case value
+      when Rule::Result then value.class.new(value.input, value.success?, rule)
       when Array then Rule::Result::Set.new(input, value, rule)
       else Rule::Result::Value.new(input, value, rule)
       end
@@ -30,6 +31,31 @@ module Dry
         alias_method :to_a, :to_ary
       end
 
+      class Rule::Result::Verified < Rule::Result
+        attr_reader :predicate_id
+
+        def initialize(result, predicate_id)
+          @input = result.input
+          @value = result.value
+          @rule = result.rule
+          @name = result.name
+          @predicate_id = predicate_id
+        end
+
+        def call
+          Validation.Result(input, success?, rule)
+        end
+
+        def to_ary
+          [:input, [name, input, [rule.to_ary]]]
+        end
+        alias_method :to_a, :to_ary
+
+        def success?
+          rule.predicate_id == predicate_id
+        end
+      end
+
       def initialize(input, value, rule)
         @input = input
         @value = value
@@ -37,6 +63,22 @@ module Dry
         @name = rule.name
       end
 
+      def call
+        self
+      end
+
+      def curry(predicate_id = nil)
+        if predicate_id
+          Rule::Result::Verified.new(self, predicate_id)
+        else
+          self
+        end
+      end
+
+      def negated
+        self.class.new(input, !value, rule)
+      end
+
       def >(other)
         if success?
           other.(input)
@@ -61,6 +103,10 @@ module Dry
         end
       end
 
+      def xor(other)
+        Validation.Result(input, success? ^ other.(input).success?, rule)
+      end
+
       def success?
         @value
       end

data/lib/dry/validation/rule_compiler.rb

@@ -18,6 +18,15 @@ module Dry
         send(:"visit_#{name}", nodes)
       end
 
+      def visit_check(node)
+        name, predicate = node
+        Rule::Check.new(name, visit(predicate))
+      end
+
+      def visit_not(node)
+        visit(node).negation
+      end
+
       def visit_key(node)
         name, predicate = node
         Rule::Key.new(name, visit(predicate))
@@ -53,6 +62,11 @@ module Dry
         visit(left) | visit(right)
       end
 
+      def visit_xor(node)
+        left, right = node
+        visit(left) ^ visit(right)
+      end
+
       def visit_implication(node)
         left, right = node
         visit(left) > visit(right)

data/lib/dry/validation/schema.rb

@@ -4,6 +4,7 @@ require 'dry/validation/error'
 require 'dry/validation/rule_compiler'
 require 'dry/validation/messages'
 require 'dry/validation/error_compiler'
+require 'dry/validation/hint_compiler'
 require 'dry/validation/result'
 require 'dry/validation/schema/result'
 
@@ -26,6 +27,10 @@ module Dry
         ErrorCompiler.new(messages)
       end
 
+      def self.hint_compiler
+        HintCompiler.new(messages, rules: rules.map(&:to_ary))
+      end
+
       def self.messages
         default =
           case config.messages
@@ -50,24 +55,49 @@ module Dry
         @__rules__ ||= []
       end
 
+      def self.schemas
+        @__schemas__ ||= []
+      end
+
       def self.groups
         @__groups__ ||= []
       end
 
-      attr_reader :rules, :groups
+      def self.checks
+        @__checks__ ||= []
+      end
+
+      attr_reader :rules, :schemas, :groups, :checks
 
       attr_reader :error_compiler
 
-      def initialize(error_compiler = self.class.error_compiler)
+      attr_reader :hint_compiler
+
+      def initialize(error_compiler = self.class.error_compiler, hint_compiler = self.class.hint_compiler)
         compiler = RuleCompiler.new(self)
         @rules = compiler.(self.class.rules.map(&:to_ary))
+        @checks = self.class.checks
         @groups = compiler.(self.class.groups.map(&:to_ary))
+        @schemas = self.class.schemas.map(&:new)
         @error_compiler = error_compiler
+        @hint_compiler = hint_compiler
       end
 
       def call(input)
         result = Validation::Result.new(rules.map { |rule| rule.(input) })
 
+        schemas.each do |schema|
+          result.merge!(schema.(input).result)
+        end
+
+        if checks.size > 0
+          compiled_checks = RuleCompiler.new(result.to_h).(checks)
+
+          compiled_checks.each do |rule|
+            result << rule.()
+          end
+        end
+
         groups.each do |group|
           result.with_values(group.rules) do |values|
             result << group.(*values)
@@ -76,7 +106,7 @@ module Dry
 
         errors = Error::Set.new(result.failures.map { |failure| Error.new(failure) })
 
-        Schema::Result.new(input, result, errors, error_compiler)
+        Schema::Result.new(input, result, errors, error_compiler, hint_compiler)
       end
 
       def [](name)