dry-validation 0.2.0 → 0.3.0

data/lib/dry/validation/rule.rb

@@ -1,5 +1,3 @@
-require 'dry/validation/result'
-
 module Dry
   module Validation
     class Rule
@@ -44,3 +42,5 @@ require 'dry/validation/rule/value'
 require 'dry/validation/rule/each'
 require 'dry/validation/rule/set'
 require 'dry/validation/rule/composite'
+require 'dry/validation/rule/group'
+require 'dry/validation/rule/result'

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

@@ -0,0 +1,21 @@
+module Dry
+  module Validation
+    class Rule::Group < Rule
+      attr_reader :rules
+
+      def initialize(identifier, predicate)
+        name, rules = identifier.to_a.first
+        @rules = rules
+        super(name, predicate)
+      end
+
+      def call(*input)
+        Validation.Result(input, predicate.(*input), self)
+      end
+
+      def type
+        :group
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Dry
+  module Validation
+    def self.Result(input, value, rule)
+      case value
+      when Array then Rule::Result::Set.new(input, value, rule)
+      else Rule::Result::Value.new(input, value, rule)
+      end
+    end
+
+    class Rule::Result
+      include Dry::Equalizer(:success?, :input, :rule)
+
+      attr_reader :input, :value, :rule, :name
+
+      class Rule::Result::Set < Rule::Result
+        def success?
+          value.all?(&:success?)
+        end
+
+        def to_ary
+          indices = value.map { |v| v.failure? ? value.index(v) : nil }.compact
+          [:input, [rule.name, input, value.values_at(*indices).map(&:to_ary)]]
+        end
+      end
+
+      class Rule::Result::Value < Rule::Result
+        def to_ary
+          [:input, [rule.name, input, [rule.to_ary]]]
+        end
+        alias_method :to_a, :to_ary
+      end
+
+      def initialize(input, value, rule)
+        @input = input
+        @value = value
+        @rule = rule
+        @name = rule.name
+      end
+
+      def >(other)
+        if success?
+          other.(input)
+        else
+          Validation.Result(input, true, rule)
+        end
+      end
+
+      def and(other)
+        if success?
+          other.(input)
+        else
+          self
+        end
+      end
+
+      def or(other)
+        if success?
+          self
+        else
+          other.(input)
+        end
+      end
+
+      def success?
+        @value
+      end
+
+      def failure?
+        ! success?
+      end
+    end
+  end
+end

data/lib/dry/validation/rule_compiler.rb

@@ -57,6 +57,11 @@ module Dry
         left, right = node
         visit(left) > visit(right)
       end
+
+      def visit_group(node)
+        identifier, predicate = node
+        Rule::Group.new(identifier, visit(predicate))
+      end
     end
   end
 end

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/result'
 require 'dry/validation/schema/result'
 
 module Dry
@@ -13,7 +14,7 @@ module Dry
       extend Definition
 
       setting :predicates, Predicates
-      setting :messages, Messages.default
+      setting :messages, :yaml
       setting :messages_file
       setting :namespace
 
@@ -26,7 +27,13 @@ module Dry
       end
 
       def self.messages
-        default = config.messages
+        default =
+          case config.messages
+          when :yaml then Messages.default
+          when :i18n then Messages::I18n.new
+          else
+            raise RuntimeError, "+#{config.messages}+ is not a valid messages identifier"
+          end
 
         if config.messages_file && config.namespace
           default.merge(config.messages_file).namespaced(config.namespace)
@@ -43,36 +50,48 @@ module Dry
         @__rules__ ||= []
       end
 
-      attr_reader :rules
+      def self.groups
+        @__groups__ ||= []
+      end
+
+      attr_reader :rules, :groups
 
       attr_reader :error_compiler
 
       def initialize(error_compiler = self.class.error_compiler)
-        @rules = RuleCompiler.new(self).(self.class.rules.map(&:to_ary))
+        compiler = RuleCompiler.new(self)
+        @rules = compiler.(self.class.rules.map(&:to_ary))
+        @groups = compiler.(self.class.groups.map(&:to_ary))
         @error_compiler = error_compiler
       end
 
       def call(input)
-        error_set = rules.each_with_object(Error::Set.new) do |rule, errors|
-          result = rule.(input)
-          errors << Error.new(result) if result.failure?
+        result = Validation::Result.new(rules.map { |rule| rule.(input) })
+
+        groups.each do |group|
+          result.with_values(group.rules) do |values|
+            result << group.(*values)
+          end
         end
 
-        Result.new(input, error_set)
-      end
+        errors = Error::Set.new(result.failures.map { |failure| Error.new(failure) })
 
-      def messages(input)
-        result = call(input)
-        Result.new(result.params, error_compiler.(result.to_ary))
+        Schema::Result.new(input, result, errors, error_compiler)
       end
 
       def [](name)
-        if methods.include?(name)
+        if predicates.key?(name)
+          predicates[name]
+        elsif respond_to?(name)
           Predicate.new(name, &method(name))
         else
-          self.class.predicates[name]
+          raise ArgumentError, "+#{name}+ is not a valid predicate name"
         end
       end
+
+      def predicates
+        self.class.predicates
+      end
     end
   end
 end

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

@@ -9,6 +9,22 @@ module Dry
         def optional(name, &block)
           Key.new(name, rules).optional(&block)
         end
+
+        def rule(name, **options)
+          predicate, rules = options.to_a.first
+          identifier = { name => rules }
+
+          groups << [:group, [identifier, [:predicate, predicate]]]
+        end
+
+        def confirmation(name)
+          identifier = :"#{name}_confirmation"
+
+          key(name, &:filled?)
+          key(identifier, &:filled?)
+
+          rule(identifier, eql?: [name, identifier])
+        end
       end
     end
   end

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

@@ -1,20 +1,26 @@
 module Dry
   module Validation
     class Schema::Result
-      include Dry::Equalizer(:params, :errors)
+      include Dry::Equalizer(:params, :messages)
       include Enumerable
 
       attr_reader :params
 
+      attr_reader :result
+
       attr_reader :errors
 
-      def initialize(params, errors)
+      attr_reader :error_compiler
+
+      def initialize(params, result, errors, error_compiler)
         @params = params
+        @result = result
         @errors = errors
+        @error_compiler = error_compiler
       end
 
       def each(&block)
-        errors.each(&block)
+        failures.each(&block)
       end
 
       def empty?
@@ -24,6 +30,18 @@ module Dry
       def to_ary
         errors.map(&:to_ary)
       end
+
+      def messages(options = {})
+        @messages ||= error_compiler.with(options).(errors.map(&:to_ary))
+      end
+
+      def successes
+        result.successes
+      end
+
+      def failures
+        result.failures
+      end
     end
   end
 end

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

@@ -2,7 +2,7 @@ module Dry
   module Validation
     class Schema
       class Rule
-        attr_reader :node
+        attr_reader :name, :node
 
         def initialize(node)
           @node = node

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

@@ -4,11 +4,12 @@ module Dry
       class Value
         include Schema::Definition
 
-        attr_reader :name, :rules
+        attr_reader :name, :rules, :groups
 
         def initialize(name)
           @name = name
           @rules = []
+          @groups = []
         end
 
         def each(&block)

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

data/spec/fixtures/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  errors:
+    rules:
+      email:
+        filled?: "Please provide your email"

data/spec/fixtures/locales/pl.yml

@@ -0,0 +1,14 @@
+pl:
+  errors:
+    filled?: "%{name} nie może być pusty"
+    size?:
+      arg:
+        default: "wielkość musi być równa %{num}"
+        range: "wielkość musi być między %{left} a %{right}"
+    rules:
+      email:
+        filled?: "Proszę podać adres email"
+      user:
+        rules:
+          email:
+            filled?: "Hej user! Dawaj ten email no!"

data/spec/integration/custom_error_messages_spec.rb

@@ -5,29 +5,17 @@ RSpec.describe Dry::Validation, 'with custom messages' do
     let(:schema) do
       Class.new(Dry::Validation::Schema) do
         configure do |config|
-          config.messages_file = SPEC_ROOT.join('fixtures/errors.yml')
-          config.namespace = :user
+          config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
         end
 
-        key(:email) { |email| email.filled? }
+        key(:email, &:filled?)
       end
     end
 
-    let(:attrs) do
-      {
-        email: 'jane@doe.org',
-        age: 19,
-        address: { city: 'NYC', street: 'Street 1/2', country: { code: 'US', name: 'USA' } },
-        phone_numbers: [
-          '123456', '234567'
-        ]
-      }.freeze
-    end
-
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.messages(attrs.merge(email: ''))).to match_array([
-          [:email, ["email can't be blank"]]
+        expect(validation.(email: '').messages).to match_array([
+          [:email, [['Please provide your email', '']]]
         ])
       end
     end

data/spec/{unit → integration}/error_compiler_spec.rb

@@ -6,10 +6,14 @@ RSpec.describe Dry::Validation::ErrorCompiler do
 
   let(:messages) do
     Messages.default.merge(
-      key?: '+%{name}+ key is missing in the hash',
-      attributes: {
-        address: {
-          filled?: 'Please provide your address'
+      en: {
+        errors: {
+          key?: '+%{name}+ key is missing in the hash',
+          rules: {
+            address: {
+              filled?: 'Please provide your address'
+            }
+          }
         }
       }
     )
@@ -26,202 +30,240 @@ RSpec.describe Dry::Validation::ErrorCompiler do
     end
 
     it 'converts error ast into another format' do
-      expect(error_compiler.(ast)).to eql([
-        [:name, ["+name+ key is missing in the hash"]],
-        [:age, ["age must be greater than 18 (18 was given)"]],
-        [:email, ["email must be filled"]],
-        [:address, ["Please provide your address"]]
-      ])
+      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", '']]
+      )
     end
   end
 
   describe '#visit_predicate' do
     describe ':empty?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:empty?, []], [], :tags)
+        msg, val = 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 = error_compiler.visit_predicate([:exclusion?, [[1, 2, 3]]], 2, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:inclusion?, [[1, 2, 3]]], 2, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:gt?, [3]], 2, :num)
+        msg, val = error_compiler.visit_predicate([:gt?, [3]], 2, :num)
 
-        expect(msg).to eql('num must be greater than 3 (2 was given)')
+        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 = error_compiler.visit_predicate([:gteq?, [3]], 2, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:lt?, [3]], 2, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:lteq?, [3]], 2, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:hash?, []], '', :address)
+        msg, val = 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 = error_compiler.visit_predicate([:array?, []], '', :phone_numbers)
+        msg, val = 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 = error_compiler.visit_predicate([:int?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:float?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:decimal?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:date?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:date_time?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:time?, []], '2', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:max_size?, [3]], 'abcd', :num)
+        msg, val = 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 = error_compiler.visit_predicate([:min_size?, [3]], 'ab', :num)
+        msg, val = 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 ':nil?' do
+    describe ':none?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:nil?, []], nil, :num)
+        msg, val = error_compiler.visit_predicate([:none?, []], nil, :num)
 
-        expect(msg).to eql('num cannot be nil')
+        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)
+
+        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)
+
+        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 = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
+        msg, val = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
 
-        expect(msg).to eql('num size must be 3')
+        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 = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
+        msg, val = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
 
-        expect(msg).to eql('num size must be within 3 - 4')
+        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 = error_compiler.visit_predicate([:str?, []], 3, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:bool?, []], 3, :num)
+        msg, val = 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 = error_compiler.visit_predicate([:format?, [/^F/]], 'Bar', :str)
+        msg, val = 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 = error_compiler.visit_predicate([:eql?, ['Bar']], 'Foo', :str)
+        msg, val = 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