dry-validation 0.1.0 → 1.8.0

data/spec/integration/validation_spec.rb

@@ -1,118 +0,0 @@
-RSpec.describe Dry::Validation do
-  subject(:validation) { schema.new }
-
-  describe 'defining schema' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        key(:email) { |email| email.filled? }
-
-        key(:age) do |age|
-          age.int? & age.gt?(18)
-        end
-
-        key(:address) do |address|
-          address.key(:city) do |city|
-            city.min_size?(3)
-          end
-
-          address.key(:street) do |street|
-            street.filled?
-          end
-
-          address.key(:country) do |country|
-            country.key(:name, &:filled?)
-            country.key(:code, &:filled?)
-          end
-        end
-
-        key(:phone_numbers) do |phone_numbers|
-          phone_numbers.each(&:str?)
-        end
-      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 eql([
-          [:email, ["email must be filled"]]
-        ])
-      end
-    end
-
-    describe '#call' do
-      it 'passes when attributes are valid' do
-        expect(validation.(attrs)).to be_empty
-      end
-
-      it 'validates presence of an email and min age value' do
-        expect(validation.(attrs.merge(email: '', age: 18))).to match_array([
-          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of the email key and type of age value' do
-        expect(validation.(name: 'Jane', age: '18', address: attrs[:address], phone_numbers: attrs[:phone_numbers])).to match_array([
-          [:error, [:input, [:age, "18", [[:val, [:age, [:predicate, [:int?, []]]]]]]]],
-          [:error, [:input, [:email, nil, [[:key, [:email, [:predicate, [:key?, [:email]]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of the address and phone_number keys' do
-        expect(validation.(email: 'jane@doe.org', age: 19)).to match_array([
-          [:error, [:input, [:address, nil, [[:key, [:address, [:predicate, [:key?, [:address]]]]]]]]],
-          [:error, [:input, [:phone_numbers, nil, [[:key, [:phone_numbers, [:predicate, [:key?, [:phone_numbers]]]]]]]]]
-        ])
-      end
-
-      it 'validates presence of keys under address and min size of the city value' do
-        expect(validation.(attrs.merge(address: { city: 'NY' }))).to match_array([
-          [:error, [
-            :input, [
-              :address, {city: "NY"},
-              [
-                [:input, [:city, "NY", [[:val, [:city, [:predicate, [:min_size?, [3]]]]]]]],
-                [:input, [:street, nil, [[:key, [:street, [:predicate, [:key?, [:street]]]]]]]],
-                [:input, [:country, nil, [[:key, [:country, [:predicate, [:key?, [:country]]]]]]]]
-              ]
-            ]
-          ]]
-        ])
-      end
-
-      it 'validates address code and name values' do
-        expect(validation.(attrs.merge(address: attrs[:address].merge(country: { code: 'US', name: '' })))).to match_array([
-          [:error, [
-            :input, [
-              :address, {city: "NYC", street: "Street 1/2", country: {code: "US", name: ""}},
-              [
-                [
-                  :input, [
-                    :country, {code: "US", name: ""}, [
-                      [
-                        :input, [
-                          :name, "", [[:val, [:name, [:predicate, [:filled?, []]]]]]
-                        ]
-                      ]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]]
-        ])
-      end
-    end
-  end
-end

data/spec/shared/predicates.rb

@@ -1,31 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.shared_examples 'predicates' do
-  let(:nil?) { Dry::Validation::Predicates[:nil?] }
-
-  let(:str?) { Dry::Validation::Predicates[:str?] }
-
-  let(:min_size?) { Dry::Validation::Predicates[:min_size?] }
-
-  let(:key?) { Dry::Validation::Predicates[:key?] }
-end
-
-RSpec.shared_examples 'a passing predicate' do
-  let(:predicate) { Dry::Validation::Predicates[predicate_name] }
-
-  it do
-    arguments_list.each do |args|
-      expect(predicate.call(*args)).to be true
-    end
-  end
-end
-
-RSpec.shared_examples 'a failing predicate' do
-  let(:predicate) { Dry::Validation::Predicates[predicate_name] }
-
-  it do
-    arguments_list.each do |args|
-      expect(predicate.call(*args)).to be false
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'dry-validation'
-
-begin
-  require 'byebug'
-rescue LoadError; end
-
-SPEC_ROOT = Pathname(__dir__)
-
-Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))
-Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
-
-include Dry::Validation
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-end

data/spec/unit/error_compiler_spec.rb

@@ -1,165 +0,0 @@
-require 'dry/validation/messages'
-require 'dry/validation/error_compiler'
-
-RSpec.describe Dry::Validation::ErrorCompiler do
-  subject(:error_compiler) { ErrorCompiler.new(messages) }
-
-  let(:messages) do
-    Messages.default.merge(
-      key?: '+%{name}+ key is missing in the hash',
-      attributes: {
-        address: {
-          filled?: 'Please provide your address'
-        }
-      }
-    )
-  end
-
-  describe '#call' do
-    let(:ast) do
-      [
-        [:error, [:input, [:name, nil, [[:key, [:name, [:predicate, [:key?, []]]]]]]]],
-        [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-        [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]],
-        [:error, [:input, [:address, "", [[:val, [:address, [:predicate, [:filled?, []]]]]]]]]
-      ]
-    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"]]
-      ])
-    end
-  end
-
-  describe '#visit_predicate' do
-    describe ':empty?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:empty?, []], [], :tags)
-
-        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)
-
-        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)
-
-        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)
-
-        expect(msg).to eql('num must be greater than 3 (2 was given)')
-      end
-    end
-
-    describe ':gteq?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:gteq?, [3]], 2, :num)
-
-        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)
-
-        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)
-
-        expect(msg).to eql('num must be less than or equal to 3')
-      end
-    end
-
-    describe ':int?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:int?, []], '2', :num)
-
-        expect(msg).to eql('num must be an integer')
-      end
-    end
-
-    describe ':max_size?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:max_size?, [3]], 'abcd', :num)
-
-        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)
-
-        expect(msg).to eql('num size cannot be less than 3')
-      end
-    end
-
-    describe ':nil?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:nil?, []], nil, :num)
-
-        expect(msg).to eql('num cannot be nil')
-      end
-    end
-
-    describe ':size?' do
-      it 'returns valid message when arg is int' do
-        msg = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
-
-        expect(msg).to eql('num size must be 3')
-      end
-
-      it 'returns valid message when arg is range' do
-        msg = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
-
-        expect(msg).to eql('num size must be within 3 - 4')
-      end
-    end
-
-    describe ':str?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:str?, []], 3, :num)
-
-        expect(msg).to eql('num must be a string')
-      end
-    end
-
-    describe ':format?' do
-      it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:format?, [/^F/]], 'Bar', :str)
-
-        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)
-
-        expect(msg).to eql('str must be equal to Bar')
-      end
-    end
-  end
-end

data/spec/unit/predicate_spec.rb

@@ -1,37 +0,0 @@
-require 'dry/validation/predicate'
-
-RSpec.describe Dry::Validation::Predicate do
-  describe '#call' do
-    it 'returns result of the predicate function' do
-      is_empty = Dry::Validation::Predicate.new(:is_empty) { |str| str.empty? }
-
-      expect(is_empty.('')).to be(true)
-
-      expect(is_empty.('filled')).to be(false)
-    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 }
-
-      min_age_18 = min_age.curry(18)
-
-      expect(min_age_18.args).to eql([18])
-
-      expect(min_age_18.(18)).to be(true)
-      expect(min_age_18.(19)).to be(true)
-      expect(min_age_18.(17)).to be(false)
-    end
-  end
-end

data/spec/unit/predicates/empty_spec.rb

@@ -1,38 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#empty?' do
-    let(:predicate_name) { :empty? }
-
-    context 'when value is empty' do
-      let(:arguments_list) do
-        [
-          [''],
-          [[]],
-          [{}],
-          [nil]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not empty' do
-      let(:arguments_list) do
-        [
-          ['Jill'],
-          [[1, 2, 3]],
-          [{ name: 'John' }],
-          [true],
-          [false],
-          ['1'],
-          ['0'],
-          [:symbol],
-          [String]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/eql_spec.rb

@@ -1,21 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates, '#eql?' do
-  let(:predicate_name) { :eql? }
-
-  context 'when value is equal to the arg' do
-    let(:arguments_list) do
-      [['Foo', 'Foo']]
-    end
-
-    it_behaves_like 'a passing predicate'
-  end
-
-  context 'with value is not empty' do
-    let(:arguments_list) do
-      [['Bar', 'Foo']]
-    end
-
-    it_behaves_like 'a failing predicate'
-  end
-end

data/spec/unit/predicates/exclusion_spec.rb

@@ -1,35 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#exclusion?' do
-    let(:predicate_name) { :exclusion? }
-
-    context 'when value is not present in list' do
-      let(:arguments_list) do
-        [
-          [['Jill', 'John'], 'Jack'],
-          [1..2, 0],
-          [1..2, 3],
-          [[nil, false], true]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is present in list' do
-      let(:arguments_list) do
-        [
-          [['Jill', 'John'], 'Jill'],
-          [['Jill', 'John'], 'John'],
-          [1..2, 1],
-          [1..2, 2],
-          [[nil, false], nil],
-          [[nil, false], false]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/filled_spec.rb

@@ -1,38 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#filled?' do
-    let(:predicate_name) { :filled? }
-
-    context 'when value is filled' do
-      let(:arguments_list) do
-        [
-          ['Jill'],
-          [[1, 2, 3]],
-          [{ name: 'John' }],
-          [true],
-          [false],
-          ['1'],
-          ['0'],
-          [:symbol],
-          [String]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not filled' do
-      let(:arguments_list) do
-        [
-          [''],
-          [[]],
-          [{}],
-          [nil]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/format_spec.rb

@@ -1,21 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates, '#format?' do
-  let(:predicate_name) { :format? }
-
-  context 'when value matches provided regexp' do
-    let(:arguments_list) do
-      [['Foo', /^F/]]
-    end
-
-    it_behaves_like 'a passing predicate'
-  end
-
-  context 'when value does not match provided regexp' do
-    let(:arguments_list) do
-      [['Bar', /^F/]]
-    end
-
-    it_behaves_like 'a failing predicate'
-  end
-end

data/spec/unit/predicates/gt_spec.rb

@@ -1,40 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#gt?' do
-    let(:predicate_name) { :gt? }
-
-    context 'when value is greater than n' do
-      let(:arguments_list) do
-        [
-          [13, 14],
-          [13.37, 13.38]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value is equal to n' do
-      let(:arguments_list) do
-        [
-          [13, 13],
-          [13.37, 13.37]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-
-    context 'with value is less than n' do
-      let(:arguments_list) do
-        [
-          [13, 12],
-          [13.37, 13.36]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/gteq_spec.rb

@@ -1,40 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#gteq?' do
-    let(:predicate_name) { :gteq? }
-
-    context 'when value is greater than n' do
-      let(:arguments_list) do
-        [
-          [13, 14],
-          [13.37, 13.38]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value is equal to n' do
-      let(:arguments_list) do
-        [
-          [13, 13],
-          [13.37, 13.37]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is less than n' do
-      let(:arguments_list) do
-        [
-          [13, 12],
-          [13.37, 13.36]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/inclusion_spec.rb

@@ -1,35 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#inclusion?' do
-    let(:predicate_name) { :inclusion? }
-
-    context 'when value is present in list' do
-      let(:arguments_list) do
-        [
-          [['Jill', 'John'], 'Jill'],
-          [['Jill', 'John'], 'John'],
-          [1..2, 1],
-          [1..2, 2],
-          [[nil, false], nil],
-          [[nil, false], false]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not present in list' do
-      let(:arguments_list) do
-        [
-          [['Jill', 'John'], 'Jack'],
-          [1..2, 0],
-          [1..2, 3],
-          [[nil, false], true]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/int_spec.rb

@@ -1,34 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#int?' do
-    let(:predicate_name) { :int? }
-
-    context 'when value is an integer' do
-      let(:arguments_list) do
-        [
-          [1],
-          [33],
-          [7]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value is not an integer' do
-      let(:arguments_list) do
-        [
-          [''],
-          [[]],
-          [{}],
-          [nil],
-          [:symbol],
-          [String]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end