dry-validation 0.12.0 → 1.6.0

data/spec/unit/message_compiler/visit_failure_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe Dry::Validation::MessageCompiler, '#visit_failure' do
-  include_context :message_compiler
-
-  let(:visitor) { :visit_failure }
-
-  context 'with :int? predicate' do
-    let(:node) do
-      [:age, [:key, [:age, [:predicate, [:int?, [[:input, '17']]]]]]]
-    end
-
-    it 'returns a message for :int? failure with :rule name inferred from key-rule' do
-      expect(result.rule).to be(:age)
-      expect(result.path).to eql([:age])
-      expect(result).to eql('must be an integer')
-    end
-  end
-
-  context 'with set failure and :int? predicate' do
-    let(:node) do
-      [:items, [:key, [:items, [:set, [
-        [:key, [0, [:predicate, [:int?, [[:input, 'foo']]]]]],
-        [:key, [2, [:predicate, [:int?, [[:input, 'bar']]]]]]
-      ]]]]]
-    end
-
-    it 'returns a message for the first element that failed' do
-      expect(result[0].rule).to be(:items)
-      expect(result[0].path).to eql([:items, 0])
-      expect(result[0]).to eql('must be an integer')
-    end
-
-    it 'returns a message for the third element that failed' do
-      expect(result[1].rule).to be(:items)
-      expect(result[1].path).to eql([:items, 2])
-      expect(result[1]).to eql('must be an integer')
-    end
-  end
-end

data/spec/unit/message_compiler/visit_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe Dry::Validation::MessageCompiler, '#visit' do
-  include_context :message_compiler
-
-  let(:visitor) { :visit }
-
-  context 'with an anonymous :failure' do
-    let(:node) do
-      [:failure, [:age, [:key, [:age, [:predicate, [:int?, [[:input, '17']]]]]]]]
-    end
-
-    it 'returns a message for :int? failure with :rule name inferred from key-rule' do
-      expect(result.rule).to be(:age)
-      expect(result).to eql('must be an integer')
-    end
-  end
-end

data/spec/unit/message_compiler_spec.rb

@@ -1,7 +0,0 @@
-RSpec.describe MessageCompiler, '#call' do
-  subject(:message_compiler) { MessageCompiler.new( Messages.default ) }
-
-  it 'returns an empty hash when there are no errors' do
-    expect(message_compiler.([])).to be_empty
-  end
-end

data/spec/unit/predicate_registry_spec.rb

@@ -1,34 +0,0 @@
-require 'dry/validation/predicate_registry'
-
-RSpec.describe PredicateRegistry do
-  subject!(:predicate_registry) { schema_class.registry }
-
-  let(:schema_class) { Class.new(Schema) }
-  let(:schema) { schema_class.new }
-
-  before do
-    schema_class.class_eval { def dis_ok?; true; end }
-  end
-
-  describe '.[]' do
-    it 'returns a registry which collects predicate methods' do
-      expect(predicate_registry[:dis_ok?]).to be_instance_of(UnboundMethod)
-    end
-  end
-
-  describe '#[]' do
-    it 'gives access to built-in predicates' do
-      expect(predicate_registry[:filled?].("sutin")).to be(true)
-    end
-  end
-
-  describe '#bind' do
-    it 'binds unbound predicates and return finalized registry' do
-      registry = predicate_registry.bind(schema)
-
-      expect(registry).to be_frozen
-      expect(registry[:dis_ok?]).to be_a(Method)
-      expect(registry[:dis_ok?].()).to be(true)
-    end
-  end
-end

data/spec/unit/schema/key_spec.rb

@@ -1,38 +0,0 @@
-RSpec.describe Schema::Key do
-  include_context 'predicate helper'
-
-  let(:registry) { PredicateRegistry.new(predicates) }
-
-  describe '#str?' do
-    subject(:user) { Schema::Key[:user, registry: registry] }
-
-    it 'returns a key rule' do
-      expect(user.str?.to_ast).to eql(
-        [:rule, [:user, [:key, [:user, [:predicate, [:str?, [[:input, Undefined]]]]]]]]
-      )
-    end
-
-    it 'returns a key rule & disjunction rule created within the block' do
-      user.hash? do
-        required(:email) { none? | filled? }
-      end
-
-      expect(user.to_ast).to eql(
-        [:key, [:user, [:rule, [:user,
-          [:and, [
-            [:rule, [:user, [:predicate, [:hash?, [[:input, Undefined]]]]]],
-            [:rule, [:user, [:key, [:user, [:rule, [:email,
-              [:and, [
-                [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-                [:rule, [:user, [:rule, [:email,
-                  [:or, [
-                    [:rule, [:email, [:key, [:email, [:predicate, [:none?, [[:input, Undefined]]]]]]]],
-                    [:rule, [:email, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                  ]]]]]]
-              ]]]]]]]
-            ]]]
-        ]]]]
-      )
-    end
-  end
-end

data/spec/unit/schema/rule_spec.rb

@@ -1,42 +0,0 @@
-RSpec.describe Schema::Rule do
-  include_context 'predicate helper'
-
-  let(:filled) { p(:filled?) }
-  let(:format) { p(:format?, /regex/) }
-
-  let(:left) { Schema::Rule.new(filled, name: :email, target: target) }
-  let(:right) { Schema::Rule.new(format, name: :email, target: target) }
-  let(:target) { double(:target, id: :user) }
-
-  describe '#and' do
-    it 'returns a conjunction' do
-      expect(left.and(right).to_ast).to match_array(
-        [:rule, [:email, [:and, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#or' do
-    it 'returns a disjunction' do
-      expect(left.or(right).to_ast).to match_array(
-        [:rule, [:email, [:or, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#xor' do
-    it 'returns an exclusive disjunction' do
-      expect(left.xor(right).to_ast).to match_array(
-        [:rule, [:email, [:xor, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-
-  describe '#then' do
-    it 'returns an implication' do
-      expect(left.then(right).to_ast).to match_array(
-        [:rule, [:email, [:implication, [[:rule, [:email, filled]], [:rule, [:email, format]]]]]]
-      )
-    end
-  end
-end

data/spec/unit/schema/value_spec.rb

@@ -1,131 +0,0 @@
-RSpec.describe Schema::Value do
-  include_context 'rule compiler'
-  include_context 'predicate helper'
-
-  let(:registry) { PredicateRegistry.new(predicates) }
-
-  describe '#required' do
-    subject(:value) { Schema::Value.new(registry: registry) }
-
-    let(:expected_ast) do
-      [:rule, [:address, [:and, [
-        [:rule, [:address, [:predicate, [:key?, [[:name, :address], [:input, Undefined]]]]]],
-        [:rule, [:address, [:key, [:address, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-      ]]]]
-    end
-
-    it 'creates a rule for a specified key using a block' do
-      rule = value.required(:address, &:filled?)
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-
-    it 'creates a rule for a specified key using a macro' do
-      rule = value.required(:address).filled
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-  end
-
-  describe '#each' do
-    subject(:value) { Schema::Value.new(registry: registry) }
-
-    it 'creates an each rule with another rule returned from the block' do
-      rule = value.each { key?(:method) }
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:array?, [[:input, Undefined]]]],
-          [:each, [:predicate, [:key?, [[:name, :method], [:input, Undefined]]]]]
-        ]]
-      )
-    end
-
-    it 'creates an each rule with other rules returned from the block' do
-      rule = value.each do
-        required(:method) { str? }
-        required(:amount) { float? }
-      end
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:array?, [[:input, Undefined]]]],
-          [:each, [:set, [
-            [:rule, [:method, [:and, [
-              [:rule, [:method, [:predicate, [:key?, [[:name, :method], [:input, Undefined]]]]]],
-              [:rule, [:method, [:key, [:method, [:predicate, [:str?, [[:input, Undefined]]]]]]]]]
-            ]]],
-            [:rule, [:amount, [:and, [
-              [:rule, [:amount, [:predicate, [:key?, [[:name, :amount], [:input, Undefined]]]]]],
-              [:rule, [:amount, [:key, [:amount, [:predicate, [:float?, [[:input, Undefined]]]]]]]]
-            ]]]]
-          ]]]
-        ]]
-      )
-    end
-  end
-
-  describe '#hash? with block' do
-    subject(:user) { Schema::Value.new(registry: registry) }
-
-    it 'builds hash? & rule created within the block' do
-      rule = user.hash? { required(:email).filled }
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:hash?, [[:input, Undefined]]]],
-          [:rule, [:email, [:and, [
-            [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-            [:rule, [:email, [:key, [:email, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-          ]]]]
-        ]]
-      )
-    end
-
-    it 'builds hash? & rule created within the block with deep nesting' do
-      rule = user.hash? do
-        required(:address) do
-          hash? do
-            required(:city).filled
-            required(:zipcode).filled
-          end
-        end
-      end
-
-      expect(rule.to_ast).to eql(
-        [:and, [
-          [:predicate, [:hash?, [[:input, Undefined]]]],
-          [:rule, [:address, [:and, [
-            [:rule, [:address, [:predicate, [:key?, [[:name, :address], [:input, Undefined]]]]]],
-            [:rule, [:address, [:and, [
-              [:rule, [:address, [:predicate, [:hash?, [[:input, Undefined]]]]]],
-              [:rule, [:address, [:key, [:address, [:set, [
-                [:rule, [:city, [:and, [
-                  [:rule, [:city, [:predicate, [:key?, [[:name, :city], [:input, Undefined]]]]]],
-                  [:rule, [:city, [:key, [:city, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                ]]]],
-                [:rule, [:zipcode, [:and, [
-                  [:rule, [:zipcode, [:predicate, [:key?, [[:name, :zipcode], [:input, Undefined]]]]]],
-                  [:rule, [:zipcode, [:key, [:zipcode, [:predicate, [:filled?, [[:input, Undefined]]]]]]]]
-                ]]]]
-              ]]]]]]
-            ]]]]
-          ]]]]
-        ]]
-      )
-    end
-  end
-
-  describe '#not' do
-    subject(:user) { Schema::Value.new(registry: registry) }
-
-    it 'builds a negated rule' do
-      not_email = user.required(:email) { str?.not }
-
-      expect(not_email.to_ast).to eql(
-        [:rule, [:email, [:and, [
-          [:rule, [:email, [:predicate, [:key?, [[:name, :email], [:input, Undefined]]]]]],
-          [:rule, [:email, [:not, [:key, [:email, [:predicate, [:str?, [[:input, Undefined]]]]]]]]]]
-        ]]]
-      )
-    end
-  end
-end

data/spec/unit/schema_spec.rb

@@ -1,35 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Schema do
-  describe '.messages' do
-    context 'with default setting' do
-      let(:schema) do
-        Class.new(Schema)
-      end
-
-      it 'returns default yaml messages' do
-        expect(schema.messages).to be_instance_of(Messages::YAML)
-      end
-    end
-
-    context 'with i18n setting' do
-      let(:schema) do
-        Class.new(Schema) { configure { config.messages = :i18n } }
-      end
-
-      it 'returns default i18n messages' do
-        expect(schema.messages).to be_instance_of(Messages::I18n)
-      end
-    end
-
-    context 'with an invalid setting' do
-      let(:schema) do
-        Class.new(Schema) { configure { config.messages = :oops } }
-      end
-
-      it 'returns default i18n messages' do
-        expect { schema.messages }.to raise_error(RuntimeError, /oops/)
-      end
-    end
-  end
-end