dry-validation 0.3.1 → 0.4.0

data/spec/integration/hints_spec.rb

@@ -0,0 +1,39 @@
+require 'dry/validation/messages/i18n'
+
+RSpec.describe 'Validation hints' do
+  subject(:validation) { schema.new }
+
+  shared_context '#messages' do
+    it 'provides hints for additional rules that were not checked' do
+      expect(validation.(age: '17').messages).to eql(
+        age: [['age must be an integer', 'age must be greater than 18'], '17']
+      )
+    end
+  end
+
+  context 'with yaml messages' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        key(:age) do |age|
+          age.none? | (age.int? & age.gt?(18))
+        end
+      end
+    end
+
+    include_context '#messages'
+  end
+
+  context 'with i18n messages' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        configure { |c| c.messages = :i18n }
+
+        key(:age) do |age|
+          age.none? | (age.int? & age.gt?(18))
+        end
+      end
+    end
+
+    include_context '#messages'
+  end
+end

data/spec/integration/localized_error_messages_spec.rb

@@ -24,7 +24,7 @@ RSpec.describe Dry::Validation, 'with localized messages' do
       describe '#messages' do
         it 'returns localized error messages' do
           expect(validation.(email: '').messages(locale: :pl)).to match_array([
-            [:email, [['Proszę podać adres email', '']]]
+            [:email, [['Proszę podać adres email'], '']]
           ])
         end
       end
@@ -45,7 +45,7 @@ RSpec.describe Dry::Validation, 'with localized messages' do
       describe '#messages' do
         it 'returns localized error messages' do
           expect(validation.(email: '').messages(locale: :pl)).to match_array([
-            [:email, [['Hej user! Dawaj ten email no!', '']]]
+            [:email, [['Hej user! Dawaj ten email no!'], '']]
           ])
         end
       end

data/spec/integration/schema/check_rules_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Schema, 'using generic rules' do
+  subject(:validate) { schema.new }
+
+  let(:schema) do
+    Class.new(Schema) do
+      def self.messages
+        Messages.default.merge(
+          en: { errors: { destiny: 'you must select either red or blue' } }
+        )
+      end
+
+      optional(:red, &:filled?)
+      optional(:blue, &:filled?)
+
+      rule(:destiny) { rule(:red) | rule(:blue) }
+    end
+  end
+
+  it 'passes when only red is filled' do
+    expect(validate.(red: '1')).to be_empty
+  end
+
+  it 'fails when red and blue are not filled ' do
+    expect(validate.(red: '', blue: '').messages[:destiny]).to eql(
+      [['you must select either red or blue'], '']
+    )
+  end
+end

data/spec/integration/schema/each_with_set_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe 'Schema with each and set rules' do
+  subject(:validation) { schema.new }
+
+  let(:schema) do
+    Class.new(Dry::Validation::Schema) do
+      key(:payments) do |payments|
+        payments.array? do
+          payments.each do |payment|
+            payment.key(:method, &:str?)
+            payment.key(:amount, &:float?)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#messages' do
+    it 'validates each payment against its set of rules' do
+      input = {
+        payments: [
+          { method: 'cc', amount: 1.23 },
+          { method: 'wire', amount: 4.56 }
+        ]
+      }
+
+      expect(validation.(input).messages).to eql({})
+    end
+
+    it 'validates presence of the method key for each payment' do
+      input = {
+        payments: [
+          { method: 'cc', amount: 1.23 },
+          { amount: 4.56 }
+        ]
+      }
+
+      expect(validation.(input).messages[:payments]).to eql([
+        [payments: [[method: [["method is missing"], nil]], input[:payments][1]]],
+        input[:payments]
+      ])
+    end
+
+    it 'validates type of the method value for each payment' do
+      input = {
+        payments: [
+          { method: 'cc', amount: 1.23 },
+          { method: 12, amount: 4.56 }
+        ]
+      }
+
+      expect(validation.(input).messages[:payments]).to eql([
+        [payments: [[method: [["method must be a string"], 12]], input[:payments][1]]],
+        input[:payments]
+      ])
+    end
+
+    it 'validates type of the amount value for each payment' do
+      input = {
+        payments: [
+          { method: 'cc', amount: 1.23 },
+          { method: 'wire', amount: '4.56' }
+        ]
+      }
+
+      expect(validation.(input).messages[:payments]).to eql([
+        [payments: [[amount: [["amount must be a float"], '4.56']], input[:payments][1]]],
+        input[:payments]
+      ])
+    end
+  end
+end

data/spec/integration/schema/nested_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe Schema, 'using nested schemas' do
+  subject(:validate) { schema.new }
+
+  let(:schema) do
+    Class.new(Schema) do
+      schema(:location) do |loc|
+        loc.key(:lat, &:filled?)
+        loc.key(:lng, &:filled?)
+      end
+    end
+  end
+
+  it 'passes when location has lat and lng filled' do
+    expect(validate.(location: { lat: 1.23, lng: 4.56 })).to be_empty
+  end
+
+  it 'fails when location has missing lat' do
+    expect(validate.(location: { lng: 4.56 })).to match_array([
+      [
+        :error, [
+          :input, [
+            :location, { lng: 4.56 },
+            [
+              [:input, [:lat, nil, [[:key, [:lat, [:predicate, [:key?, [:lat]]]]]]]]
+            ]
+          ]
+        ]
+      ]
+    ])
+  end
+end

data/spec/integration/schema/not_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe 'Schema with negated rules' do
+  subject(:validate) { schema.new }
+
+  let(:schema) do
+    Class.new(Dry::Validation::Schema) do
+      def self.messages
+        Messages.default.merge(
+          en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
+        )
+      end
+
+      optional(:eat_cake) { |v| v.eql?('yes!') }
+      optional(:have_cake) { |v| v.eql?('yes!') }
+
+      rule(:be_reasonable) do
+        rule(:eat_cake) & rule(:have_cake).not
+      end
+    end
+  end
+
+  describe '#messages' do
+    it 'passes when only one option is selected' do
+      messages = validate.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
+
+      expect(messages).to be(nil)
+    end
+
+    it 'fails when both options are selected' do
+      messages = validate.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
+
+      expect(messages).to eql([['you cannot eat cake and have cake!'], 'yes!'])
+    end
+  end
+end

data/spec/integration/schema/xor_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe 'Schema with xor rules' do
+  subject(:validate) { schema.new }
+
+  let(:schema) do
+    Class.new(Dry::Validation::Schema) do
+      def self.messages
+        Messages.default.merge(
+          en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
+        )
+      end
+
+      key(:eat_cake) { |v| v.eql?('yes!') }
+      key(:have_cake) { |v| v.eql?('yes!') }
+
+      rule(:be_reasonable) { rule(:eat_cake) ^ rule(:have_cake) }
+    end
+  end
+
+  describe '#messages' do
+    it 'passes when only one option is selected' do
+      messages = validate.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
+
+      expect(messages).to be(nil)
+    end
+
+    it 'fails when both options are selected' do
+      messages = validate.(eat_cake: 'yes!', have_cake: 'yes!').messages[:be_reasonable]
+
+      expect(messages).to eql([['you cannot eat cake and have cake!'], 'yes!'])
+    end
+  end
+end

data/spec/integration/schema_form_spec.rb

@@ -33,8 +33,8 @@ RSpec.describe Dry::Validation::Schema::Form do
         result = validation.('email' => '', 'age' => '19')
 
         expect(result.messages).to match_array([
-          [:email, [['email must be filled', '']]],
-          [:address, [['address is missing', nil]]]
+          [:email, [['email must be filled'], '']],
+          [:address, [['address is missing'], nil]]
         ])
 
         expect(result.params).to eql(email: '', age: 19)

data/spec/integration/schema_spec.rb

@@ -47,7 +47,7 @@ RSpec.describe Dry::Validation::Schema do
     describe '#messages' do
       it 'returns compiled error messages' do
         expect(validation.(attrs.merge(email: '')).messages).to match_array([
-          [:email, [['email must be filled', '']]]
+          [:email, [['email must be filled'], '']]
         ])
       end
     end

data/spec/shared/predicates.rb

@@ -5,6 +5,8 @@ RSpec.shared_examples 'predicates' do
 
   let(:str?) { Dry::Validation::Predicates[:str?] }
 
+  let(:filled?) { Dry::Validation::Predicates[:filled?] }
+
   let(:min_size?) { Dry::Validation::Predicates[:min_size?] }
 
   let(:key?) { Dry::Validation::Predicates[:key?] }

data/spec/spec_helper.rb

@@ -1,11 +1,11 @@
 # encoding: utf-8
 
-require 'dry-validation'
-
 begin
   require 'byebug'
 rescue LoadError; end
 
+require 'dry-validation'
+
 SPEC_ROOT = Pathname(__dir__)
 
 Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))

data/spec/unit/hint_compiler_spec.rb

@@ -0,0 +1,32 @@
+require 'dry/validation/hint_compiler'
+
+RSpec.describe HintCompiler, '#call' do
+  subject(:compiler) { HintCompiler.new(Messages.default, rules: rules) }
+
+  let(:rules) do
+    [
+      [
+        :and, [
+          [:key, [:age, [:predicate, [:key?, []]]]],
+          [
+            :or, [
+              [:val, [:age, [:predicate, [:none?, []]]]],
+              [
+                :and, [
+                  [:val, [:age, [:predicate, [:int?, []]]]],
+                  [:val, [:age, [:predicate, [:gt?, [18]]]]]
+                ]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+  end
+
+  it 'returns hint messages for given rules' do
+    expect(compiler.call).to eql(
+      age: ['age must be an integer', 'age must be greater than 18']
+    )
+  end
+end

data/spec/unit/predicate_spec.rb

@@ -11,16 +11,6 @@ RSpec.describe Dry::Validation::Predicate do
     end
   end
 
-  describe '#negation' do
-    it 'returns a negated version of a predicate' do
-      is_empty = Dry::Validation::Predicate.new(:is_empty) { |str| str.empty? }
-      is_filled = is_empty.negation
-
-      expect(is_filled.('')).to be(false)
-      expect(is_filled.('filled')).to be(true)
-    end
-  end
-
   describe '#curry' do
     it 'returns curried predicate' do
       min_age = Dry::Validation::Predicate.new(:min_age) { |age, input| input >= age }

data/spec/unit/rule/check_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Rule::Check do
+  subject(:rule) { Rule::Check.new(:name, other.(input).curry(predicate)) }
+
+  include_context 'predicates'
+
+  let(:other) do
+    Rule::Value.new(:name, none?).or(Rule::Value.new(:name, filled?))
+  end
+
+  describe '#call' do
+    context 'when a given predicate passed' do
+      let(:input) { 'Jane' }
+      let(:predicate) { :filled? }
+
+      it 'returns a success' do
+        expect(rule.()).to be_success
+      end
+    end
+
+    context 'when a given predicate did not pass' do
+      let(:input) { nil }
+      let(:predicate) { :filled? }
+
+      it 'returns a failure' do
+        expect(rule.()).to be_failure
+      end
+    end
+  end
+end

data/spec/unit/rule_compiler_spec.rb

@@ -4,15 +4,20 @@ RSpec.describe Dry::Validation::RuleCompiler, '#call' do
   subject(:compiler) { RuleCompiler.new(predicates) }
 
   let(:predicates) {
-    { key?: predicate, filled?: predicate }
+    { key?: predicate,
+      filled?: predicate,
+      email: val_rule.('email').curry(:filled?) }
   }
 
   let(:predicate) { double(:predicate).as_null_object }
 
   let(:key_rule) { Rule::Key.new(:email, predicate) }
+  let(:not_key_rule) { Rule::Key.new(:email, predicate).negation }
   let(:val_rule) { Rule::Value.new(:email, predicate) }
+  let(:check_rule) { Rule::Check.new(:email, predicates[:email]) }
   let(:and_rule) { key_rule & val_rule }
   let(:or_rule) { key_rule | val_rule }
+  let(:xor_rule) { key_rule ^ val_rule }
   let(:set_rule) { Rule::Set.new(:email, [val_rule]) }
   let(:each_rule) { Rule::Each.new(:email, val_rule) }
 
@@ -24,12 +29,29 @@ RSpec.describe Dry::Validation::RuleCompiler, '#call' do
     expect(rules).to eql([key_rule])
   end
 
+  it 'compiles check rules' do
+    ast = [[:check, [:email, [:predicate, [:email, [:filled?]]]]]]
+
+    rules = compiler.(ast)
+
+    expect(rules).to eql([check_rule])
+  end
+
+
+  it 'compiles negated rules' do
+    ast = [[:not, [:key, [:email, [:predicate, [:key?, predicate]]]]]]
+
+    rules = compiler.(ast)
+
+    expect(rules).to eql([not_key_rule])
+  end
+
   it 'compiles conjunction rules' do
     ast = [
       [
         :and, [
-          [:key, [:email, [:predicate, [:key?, predicate]]]],
-          [:val, [:email, [:predicate, [:filled?, predicate]]]]
+          [:key, [:email, [:predicate, [:key?, []]]]],
+          [:val, [:email, [:predicate, [:filled?, []]]]]
         ]
       ]
     ]
@@ -43,8 +65,8 @@ RSpec.describe Dry::Validation::RuleCompiler, '#call' do
     ast = [
       [
         :or, [
-          [:key, [:email, [:predicate, [:key?, predicate]]]],
-          [:val, [:email, [:predicate, [:filled?, predicate]]]]
+          [:key, [:email, [:predicate, [:key?, []]]]],
+          [:val, [:email, [:predicate, [:filled?, []]]]]
         ]
       ]
     ]
@@ -54,12 +76,27 @@ RSpec.describe Dry::Validation::RuleCompiler, '#call' do
     expect(rules).to eql([or_rule])
   end
 
+  it 'compiles exclusive disjunction rules' do
+    ast = [
+      [
+        :xor, [
+          [:key, [:email, [:predicate, [:key?, []]]]],
+          [:val, [:email, [:predicate, [:filled?, []]]]]
+        ]
+      ]
+    ]
+
+    rules = compiler.(ast)
+
+    expect(rules).to eql([xor_rule])
+  end
+
   it 'compiles set rules' do
     ast = [
       [
         :set, [
           :email, [
-            [:val, [:email, [:predicate, [:filled?, predicate]]]]
+            [:val, [:email, [:predicate, [:filled?, []]]]]
           ]
         ]
       ]
@@ -74,7 +111,7 @@ RSpec.describe Dry::Validation::RuleCompiler, '#call' do
     ast = [
       [
         :each, [
-          :email, [:val, [:email, [:predicate, [:filled?, predicate]]]]
+          :email, [:val, [:email, [:predicate, [:filled?, []]]]]
         ]
       ]
     ]