dry-validation 0.1.0 → 1.8.0

data/spec/unit/predicates/key_spec.rb

@@ -1,29 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#key?' do
-    let(:predicate_name) { :key? }
-
-    context 'when key is present in value' do
-      let(:arguments_list) do
-        [
-          [:name, { name: 'John' }],
-          [:age, { age: 18 }]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with key is not present in value' do
-      let(:arguments_list) do
-        [
-          [:name, { age: 18 }],
-          [:age, { name: 'Jill' }]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/lt_spec.rb

@@ -1,40 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#lt?' do
-    let(:predicate_name) { :lt? }
-
-    context 'when value is less than n' do
-      let(:arguments_list) do
-        [
-          [13, 12],
-          [13.37, 13.36],
-        ]
-      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 greater than n' do
-      let(:arguments_list) do
-        [
-          [13, 14],
-          [13.37, 13.38]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/lteq_spec.rb

@@ -1,40 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#lteq?' do
-    let(:predicate_name) { :lteq? }
-
-    context 'when value is less than n' do
-      let(:arguments_list) do
-        [
-          [13, 12],
-          [13.37, 13.36]
-        ]
-      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 greater than n' do
-      let(:arguments_list) do
-        [
-          [13, 14],
-          [13.37, 13.38]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/max_size_spec.rb

@@ -1,49 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#max_size?' do
-    let(:predicate_name) { :max_size? }
-
-    context 'when value size is less than n' do
-      let(:arguments_list) do
-        [
-          [3, [1, 2]],
-          [5, 'Jill'],
-          [3, { 1 => 'st', 2 => 'nd' }],
-          [9, 1],
-          [6, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value size is equal to n' do
-      let(:arguments_list) do
-        [
-          [2, [1, 2]],
-          [4, 'Jill'],
-          [2, { 1 => 'st', 2 => 'nd' }],
-          [8, 1],
-          [5, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value size is greater than n' do
-      let(:arguments_list) do
-        [
-          [1, [1, 2]],
-          [3, 'Jill'],
-          [1, { 1 => 'st', 2 => 'nd' }],
-          [7, 1],
-          [4, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/min_size_spec.rb

@@ -1,49 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#min_size?' do
-    let(:predicate_name) { :min_size? }
-
-    context 'when value size is greater than n' do
-      let(:arguments_list) do
-        [
-          [1, [1, 2]],
-          [3, 'Jill'],
-          [1, { 1 => 'st', 2 => 'nd' }],
-          [7, 1],
-          [4, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value size is equal to n' do
-      let(:arguments_list) do
-        [
-          [2, [1, 2]],
-          [4, 'Jill'],
-          [2, { 1 => 'st', 2 => 'nd' }],
-          [8, 1],
-          [5, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'with value size is less than n' do
-      let(:arguments_list) do
-        [
-          [3, [1, 2]],
-          [5, 'Jill'],
-          [3, { 1 => 'st', 2 => 'nd' }],
-          [9, 1],
-          [6, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/nil_spec.rb

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

data/spec/unit/predicates/size_spec.rb

@@ -1,49 +0,0 @@
-require 'dry/validation/predicates'
-
-RSpec.describe Dry::Validation::Predicates do
-  describe '#size?' do
-    let(:predicate_name) { :size? }
-
-    context 'when value size is equal to n' do
-      let(:arguments_list) do
-        [
-          [2, [1, 2]],
-          [4, 'Jill'],
-          [2, { 1 => 'st', 2 => 'nd' }],
-          [8, 1],
-          [5, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a passing predicate'
-    end
-
-    context 'when value size is less than n' do
-      let(:arguments_list) do
-        [
-          [3, [1, 2]],
-          [5, 'Jill'],
-          [3, { 1 => 'st', 2 => 'nd' }],
-          [9, 1],
-          [6, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-
-    context 'with value size is greater than n' do
-      let(:arguments_list) do
-        [
-          [1, [1, 2]],
-          [3, 'Jill'],
-          [1, { 1 => 'st', 2 => 'nd' }],
-          [7, 1],
-          [4, 1..5]
-        ]
-      end
-
-      it_behaves_like 'a failing predicate'
-    end
-  end
-end

data/spec/unit/predicates/str_spec.rb

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

data/spec/unit/rule/each_spec.rb

@@ -1,20 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Each do
-  include_context 'predicates'
-
-  subject(:address_rule) do
-    Dry::Validation::Rule::Each.new(:name, is_string)
-  end
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-  describe '#call' do
-    it 'applies its rules to all elements in the input' do
-      expect(address_rule.(['Address'])).to be_success
-
-      expect(address_rule.([nil, 'Address'])).to be_failure
-      expect(address_rule.([:Address, 'Address'])).to be_failure
-    end
-  end
-end

data/spec/unit/rule/key_spec.rb

@@ -1,27 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Key do
-  include_context 'predicates'
-
-  subject(:rule) { Dry::Validation::Rule::Key.new(:name, key?) }
-
-  describe '#call' do
-    it 'applies predicate to the value' do
-      expect(rule.(name: 'Jane')).to be_success
-      expect(rule.({})).to be_failure
-    end
-  end
-
-  describe '#and' do
-    let(:other) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-    it 'returns conjunction rule where value is passed to the right' do
-      present_and_string = rule.and(other)
-
-      expect(present_and_string.(name: 'Jane')).to be_success
-
-      expect(present_and_string.({})).to be_failure
-      expect(present_and_string.(name: 1)).to be_failure
-    end
-  end
-end

data/spec/unit/rule/set_spec.rb

@@ -1,32 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Set do
-  include_context 'predicates'
-
-  subject(:rule) do
-    Dry::Validation::Rule::Set.new(:address, [is_string, min_size.curry(6)])
-  end
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-  let(:min_size) { Dry::Validation::Rule::Value.new(:name, min_size?) }
-
-  describe '#call' do
-    it 'applies its rules to the input' do
-      expect(rule.('Address')).to be_success
-      expect(rule.('Addr')).to be_failure
-    end
-  end
-
-  describe '#to_ary' do
-    it 'returns an array representation' do
-      expect(rule).to match_array([
-        :set, [
-          :address, [
-            [:val, [:name, [:predicate, [:str?, []]]]],
-            [:val, [:name, [:predicate, [:min_size?, [6]]]]]
-          ]
-        ]
-      ])
-    end
-  end
-end

data/spec/unit/rule/value_spec.rb

@@ -1,42 +0,0 @@
-require 'dry/validation/rule'
-
-RSpec.describe Dry::Validation::Rule::Value do
-  include_context 'predicates'
-
-  let(:is_nil) { Dry::Validation::Rule::Value.new(:name, nil?) }
-
-  let(:is_string) { Dry::Validation::Rule::Value.new(:name, str?) }
-
-  let(:min_size) { Dry::Validation::Rule::Value.new(:name, min_size?) }
-
-  describe '#call' do
-    it 'returns result of a predicate' do
-      expect(is_string.(1)).to be_failure
-      expect(is_string.('1')).to be_success
-    end
-  end
-
-  describe '#and' do
-    it 'returns a conjunction' do
-      string_and_min_size = is_string.and(min_size.curry(3))
-
-      expect(string_and_min_size.('abc')).to be_success
-      expect(string_and_min_size.('abcd')).to be_success
-
-      expect(string_and_min_size.(1)).to be_failure
-      expect(string_and_min_size.('ab')).to be_failure
-    end
-  end
-
-  describe '#or' do
-    it 'returns a disjunction' do
-      nil_or_string = is_nil.or(is_string)
-
-      expect(nil_or_string.(nil)).to be_success
-      expect(nil_or_string.('abcd')).to be_success
-
-      expect(nil_or_string.(true)).to be_failure
-      expect(nil_or_string.(1)).to be_failure
-    end
-  end
-end

data/spec/unit/rule_compiler_spec.rb

@@ -1,86 +0,0 @@
-require 'dry/validation/rule_compiler'
-
-RSpec.describe Dry::Validation::RuleCompiler, '#call' do
-  subject(:compiler) { RuleCompiler.new(predicates) }
-
-  let(:predicates) {
-    { key?: predicate, filled?: predicate }
-  }
-
-  let(:predicate) { double(:predicate).as_null_object }
-
-  let(:key_rule) { Rule::Key.new(:email, predicate) }
-  let(:val_rule) { Rule::Value.new(:email, predicate) }
-  let(:and_rule) { key_rule & val_rule }
-  let(:or_rule) { key_rule | val_rule }
-  let(:set_rule) { Rule::Set.new(:email, [val_rule]) }
-  let(:each_rule) { Rule::Each.new(:email, val_rule) }
-
-  it 'compiles key rules' do
-    ast = [[:key, [:email, [:predicate, [:key?, predicate]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([key_rule])
-  end
-
-  it 'compiles conjunction rules' do
-    ast = [
-      [
-        :and, [
-          [:key, [:email, [:predicate, [:key?, predicate]]]],
-          [:val, [:email, [:predicate, [:filled?, predicate]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([and_rule])
-  end
-
-  it 'compiles disjunction rules' do
-    ast = [
-      [
-        :or, [
-          [:key, [:email, [:predicate, [:key?, predicate]]]],
-          [:val, [:email, [:predicate, [:filled?, predicate]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([or_rule])
-  end
-
-  it 'compiles set rules' do
-    ast = [
-      [
-        :set, [
-          :email, [
-            [:val, [:email, [:predicate, [:filled?, predicate]]]]
-          ]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([set_rule])
-  end
-
-  it 'compiles each rules' do
-    ast = [
-      [
-        :each, [
-          :email, [:val, [:email, [:predicate, [:filled?, predicate]]]]
-        ]
-      ]
-    ]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([each_rule])
-  end
-end