dry-validation 0.3.1 → 0.4.0

data/lib/dry/validation/schema/definition.rb

@@ -2,6 +2,13 @@ module Dry
   module Validation
     class Schema
       module Definition
+        def schema(name, &block)
+          schema = Class.new(superclass)
+          schema.key(name, &block)
+          schemas << schema
+          self
+        end
+
         def key(name, &block)
           Key.new(name, rules).key?(&block)
         end
@@ -10,11 +17,19 @@ module Dry
           Key.new(name, rules).optional(&block)
         end
 
-        def rule(name, **options)
-          predicate, rules = options.to_a.first
-          identifier = { name => rules }
+        def rule(name, **options, &block)
+          if options.any?
+            predicate, rule_names = options.to_a.first
+            identifier = { name => rule_names }
 
-          groups << [:group, [identifier, [:predicate, predicate]]]
+            groups << [:group, [identifier, [:predicate, predicate]]]
+          else
+            if block
+              checks << Schema::Rule.new(name, [:check, [name, yield.to_ary]])
+            else
+              rule_by_name(name).to_check
+            end
+          end
         end
 
         def confirmation(name)
@@ -25,6 +40,12 @@ module Dry
 
           rule(identifier, eql?: [name, identifier])
         end
+
+        private
+
+        def rule_by_name(name)
+          rules.detect { |rule| rule.name == name }
+        end
       end
     end
   end

data/lib/dry/validation/schema/key.rb

@@ -3,7 +3,7 @@ require 'dry/validation/rule'
 module Dry
   module Validation
     class Schema
-      class Key
+      class Key < BasicObject
         attr_reader :name, :rules
 
         def initialize(name, rules, &block)
@@ -17,10 +17,10 @@ module Dry
           val_rule = yield(Value.new(name))
 
           rules <<
-            if val_rule.is_a?(Array)
-              Schema::Rule.new([:implication, [key_rule.to_ary, [:set, [name, val_rule.map(&:to_ary)]]]])
+            if val_rule.is_a?(::Array)
+              Schema::Rule.new(name, [:implication, [key_rule.to_ary, [:set, [name, val_rule.map(&:to_ary)]]]])
             else
-              Schema::Rule.new([:implication, [key_rule.to_ary, val_rule.to_ary]])
+              Schema::Rule.new(name, [:implication, [key_rule.to_ary, val_rule.to_ary]])
             end
         end
 
@@ -33,13 +33,13 @@ module Dry
             val_rule = yield(Value.new(name))
 
             rules <<
-              if val_rule.is_a?(Array)
-                Schema::Rule.new([:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
+              if val_rule.is_a?(::Array)
+                Schema::Rule.new(name, [:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
               else
-                Schema::Rule.new([:and, [key_rule, val_rule.to_ary]])
+                Schema::Rule.new(name, [:and, [key_rule, val_rule.to_ary]])
               end
           else
-            Schema::Rule.new(key_rule)
+            Schema::Rule.new(name, key_rule)
           end
         end
 

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

@@ -12,11 +12,14 @@ module Dry
 
       attr_reader :error_compiler
 
-      def initialize(params, result, errors, error_compiler)
+      attr_reader :hint_compiler
+
+      def initialize(params, result, errors, error_compiler, hint_compiler)
         @params = params
         @result = result
         @errors = errors
         @error_compiler = error_compiler
+        @hint_compiler = hint_compiler
       end
 
       def each(&block)
@@ -32,7 +35,17 @@ module Dry
       end
 
       def messages(options = {})
-        @messages ||= error_compiler.with(options).(errors.map(&:to_ary))
+        @messages ||=
+          begin
+            all_msgs = error_compiler.with(options).(errors.map(&:to_ary))
+            hints = hint_compiler.with(options).call
+
+            all_msgs.each do |(name, data)|
+              data[0].concat(hints[name]).uniq!
+            end
+
+            all_msgs
+          end
       end
 
       def successes

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

@@ -4,7 +4,14 @@ module Dry
       class Rule
         attr_reader :name, :node
 
-        def initialize(node)
+        class Check < Rule
+          def method_missing(meth, *)
+            self.class.new(name, [:check, [name, [:predicate, [name, [meth]]]]])
+          end
+        end
+
+        def initialize(name, node)
+          @name = name
           @node = node
         end
 
@@ -13,13 +20,33 @@ module Dry
         end
         alias_method :to_a, :to_ary
 
-        def &(other)
-          self.class.new([:and, [node, other.to_ary]])
+        def to_check
+          Rule::Check.new(name, [:check, [name, [:predicate, [name, []]]]])
+        end
+
+        def not
+          self.class.new(:"not_#{name}", [:not, node])
+        end
+
+        def and(other)
+          self.class.new(:"#{name}_and_#{other.name}", [:and, [node, other.to_ary]])
+        end
+        alias_method :&, :and
+
+        def or(other)
+          self.class.new(:"#{name}_or_#{other.name}", [:or, [node, other.to_ary]])
+        end
+        alias_method :|, :or
+
+        def xor(other)
+          self.class.new(:"#{name}_xor_#{other.name}", [:xor, [node, other.to_ary]])
         end
+        alias_method :^, :xor
 
-        def |(other)
-          self.class.new([:or, [node, other.to_ary]])
+        def then(other)
+          self.class.new(:"#{name}_then_#{other.name}", [:implication, [node, other.to_ary]])
         end
+        alias_method :>, :then
       end
     end
   end

data/lib/dry/validation/schema/value.rb

@@ -1,26 +1,35 @@
 module Dry
   module Validation
     class Schema
-      class Value
+      class Value < BasicObject
         include Schema::Definition
 
-        attr_reader :name, :rules, :groups
+        attr_reader :name, :rules, :groups, :checks
 
         def initialize(name)
           @name = name
           @rules = []
           @groups = []
+          @checks = []
         end
 
         def each(&block)
-          rule = yield(self).to_ary
-          Schema::Rule.new([:each, [name, rule]])
+          val_rule = yield(self)
+
+          each_rule =
+            if val_rule.is_a?(Schema::Rule)
+              val_rule.to_ary
+            else
+              [:set, [name, rules.map(&:to_ary)]]
+            end
+
+          Schema::Rule.new(name, [:each, [name, each_rule]])
         end
 
         private
 
         def method_missing(meth, *args, &block)
-          rule = Schema::Rule.new([:val, [name, [:predicate, [meth, args]]]])
+          rule = Schema::Rule.new(name, [:val, [name, [:predicate, [meth, args]]]])
 
           if block
             val_rule = yield
@@ -28,7 +37,7 @@ module Dry
             if val_rule.is_a?(Schema::Rule)
               rule & val_rule
             else
-              Schema::Rule.new([:and, [rule.to_ary, [:set, [name, rules.map(&:to_ary)]]]])
+              Schema::Rule.new(name, [:and, [rule.to_ary, [:set, [name, rules.map(&:to_ary)]]]])
             end
           else
             rule

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.3.1'.freeze
+    VERSION = '0.4.0'.freeze
   end
 end

data/spec/integration/custom_error_messages_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Dry::Validation do
     describe '#messages' do
       it 'returns compiled error messages' do
         expect(validation.(email: '').messages).to match_array([
-          [:email, [['Please provide your email', '']]]
+          [:email, [['Please provide your email'], '']]
         ])
       end
     end

data/spec/integration/error_compiler_spec.rb

@@ -31,10 +31,10 @@ RSpec.describe Dry::Validation::ErrorCompiler do
 
     it 'converts error ast into another format' do
       expect(error_compiler.(ast)).to eql(
-        name: [["+name+ key is missing in the hash", nil]],
-        age: [["age must be greater than 18", 18]],
-        email: [["email must be filled", '']],
-        address: [["Please provide your address", '']]
+        name: [["+name+ key is missing in the hash"], nil],
+        age: [["age must be greater than 18"], 18],
+        email: [["email must be filled"], ''],
+        address: [["Please provide your address"], '']
       )
     end
   end
@@ -42,228 +42,202 @@ RSpec.describe Dry::Validation::ErrorCompiler do
   describe '#visit_predicate' do
     describe ':empty?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:empty?, []], [], :tags)
+        msg = error_compiler.visit_predicate([:empty?, []], [], :tags)
 
-        expect(val).to eql([])
         expect(msg).to eql('tags cannot be empty')
       end
     end
 
     describe ':exclusion?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:exclusion?, [[1, 2, 3]]], 2, :num)
+        msg = error_compiler.visit_predicate([:exclusion?, [[1, 2, 3]]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must not be one of: 1, 2, 3')
       end
     end
 
     describe ':inclusion?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:inclusion?, [[1, 2, 3]]], 2, :num)
+        msg = error_compiler.visit_predicate([:inclusion?, [[1, 2, 3]]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must be one of: 1, 2, 3')
       end
     end
 
     describe ':gt?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:gt?, [3]], 2, :num)
+        msg = error_compiler.visit_predicate([:gt?, [3]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must be greater than 3')
       end
     end
 
     describe ':gteq?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:gteq?, [3]], 2, :num)
+        msg = error_compiler.visit_predicate([:gteq?, [3]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must be greater than or equal to 3')
       end
     end
 
     describe ':lt?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:lt?, [3]], 2, :num)
+        msg = error_compiler.visit_predicate([:lt?, [3]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must be less than 3 (2 was given)')
       end
     end
 
     describe ':lteq?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:lteq?, [3]], 2, :num)
+        msg = error_compiler.visit_predicate([:lteq?, [3]], 2, :num)
 
-        expect(val).to be(2)
         expect(msg).to eql('num must be less than or equal to 3')
       end
     end
 
     describe ':hash?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:hash?, []], '', :address)
+        msg = error_compiler.visit_predicate([:hash?, []], '', :address)
 
-        expect(val).to eql('')
         expect(msg).to eql('address must be a hash')
       end
     end
 
     describe ':array?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:array?, []], '', :phone_numbers)
+        msg = error_compiler.visit_predicate([:array?, []], '', :phone_numbers)
 
-        expect(val).to eql('')
         expect(msg).to eql('phone_numbers must be an array')
       end
     end
 
     describe ':int?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:int?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:int?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be an integer')
       end
     end
 
     describe ':float?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:float?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:float?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be a float')
       end
     end
 
     describe ':decimal?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:decimal?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:decimal?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be a decimal')
       end
     end
 
     describe ':date?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:date?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:date?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be a date')
       end
     end
 
     describe ':date_time?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:date_time?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:date_time?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be a date time')
       end
     end
 
     describe ':time?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:time?, []], '2', :num)
+        msg = error_compiler.visit_predicate([:time?, []], '2', :num)
 
-        expect(val).to eql('2')
         expect(msg).to eql('num must be a time')
       end
     end
 
     describe ':max_size?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:max_size?, [3]], 'abcd', :num)
+        msg = error_compiler.visit_predicate([:max_size?, [3]], 'abcd', :num)
 
-        expect(val).to eql('abcd')
         expect(msg).to eql('num size cannot be greater than 3')
       end
     end
 
     describe ':min_size?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:min_size?, [3]], 'ab', :num)
+        msg = error_compiler.visit_predicate([:min_size?, [3]], 'ab', :num)
 
-        expect(val).to eql('ab')
         expect(msg).to eql('num size cannot be less than 3')
       end
     end
 
     describe ':none?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:none?, []], nil, :num)
+        msg = error_compiler.visit_predicate([:none?, []], nil, :num)
 
-        expect(val).to be(nil)
         expect(msg).to eql('num cannot be defined')
       end
     end
 
     describe ':size?' do
       it 'returns valid message when val is array and arg is int' do
-        msg, val = error_compiler.visit_predicate([:size?, [3]], [1], :numbers)
+        msg = error_compiler.visit_predicate([:size?, [3]], [1], :numbers)
 
-        expect(val).to eql([1])
         expect(msg).to eql('numbers size must be 3')
       end
 
       it 'returns valid message when val is array and arg is range' do
-        msg, val = error_compiler.visit_predicate([:size?, [3..4]], [1], :numbers)
+        msg = error_compiler.visit_predicate([:size?, [3..4]], [1], :numbers)
 
-        expect(val).to eql([1])
         expect(msg).to eql('numbers size must be within 3 - 4')
       end
 
       it 'returns valid message when arg is int' do
-        msg, val = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
+        msg = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
 
-        expect(val).to eql('ab')
         expect(msg).to eql('num length must be 3')
       end
 
       it 'returns valid message when arg is range' do
-        msg, val = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
+        msg = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
 
-        expect(val).to eql('ab')
         expect(msg).to eql('num length must be within 3 - 4')
       end
     end
 
     describe ':str?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:str?, []], 3, :num)
+        msg = error_compiler.visit_predicate([:str?, []], 3, :num)
 
-        expect(val).to be(3)
         expect(msg).to eql('num must be a string')
       end
     end
 
     describe ':bool?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:bool?, []], 3, :num)
+        msg = error_compiler.visit_predicate([:bool?, []], 3, :num)
 
-        expect(val).to be(3)
         expect(msg).to eql('num must be boolean')
       end
     end
 
     describe ':format?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:format?, [/^F/]], 'Bar', :str)
+        msg = error_compiler.visit_predicate([:format?, [/^F/]], 'Bar', :str)
 
-        expect(val).to eql('Bar')
         expect(msg).to eql('str is in invalid format')
       end
     end
 
     describe ':eql?' do
       it 'returns valid message' do
-        msg, val = error_compiler.visit_predicate([:eql?, ['Bar']], 'Foo', :str)
+        msg = error_compiler.visit_predicate([:eql?, ['Bar']], 'Foo', :str)
 
-        expect(val).to eql('Foo')
         expect(msg).to eql('str must be equal to Bar')
       end
     end