dry-validation 0.1.0

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec 'bundle exec rubocop --auto-gen-config'
+    end
+  end
+
+rescue LoadError
+end

data/spec/fixtures/errors.yml

@@ -0,0 +1,4 @@
+user:
+  attributes:
+    email:
+      filled?: "%{name} can't be blank"

data/spec/integration/custom_error_messages_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe Dry::Validation, 'with custom messages' do
+  subject(:validation) { schema.new }
+
+  describe 'defining schema' 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
+        end
+
+        key(:email) { |email| 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 eql([
+          [:email, ["email can't be blank"]]
+        ])
+      end
+    end
+  end
+end

data/spec/integration/custom_predicates_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe Dry::Validation do
+  subject(:validation) { schema.new }
+
+  shared_context 'uses custom predicates' do
+    it 'uses provided custom predicates' do
+      expect(validation.(email: 'jane@doe')).to be_empty
+
+      expect(validation.(email: nil)).to match_array([
+        [:error, [:input, [:email, nil, [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
+      ])
+
+      expect(validation.(email: 'jane')).to match_array([
+        [:error, [:input, [:email, 'jane', [[:val, [:email, [:predicate, [:email?, []]]]]]]]]
+      ])
+    end
+  end
+
+  describe 'defining schema with custom predicates container' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        configure do |config|
+          config.predicates = Test::Predicates
+        end
+
+        key(:email) { |value| value.filled? & value.email? }
+      end
+    end
+
+    before do
+      module Test
+        module Predicates
+          include Dry::Validation::Predicates
+
+          predicate(:email?) do |input|
+            input.include?('@') # for the lols
+          end
+        end
+      end
+    end
+
+    include_context 'uses custom predicates'
+  end
+
+  describe 'defining schema with custom predicate methods' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        key(:email) { |value| value.filled? & value.email? }
+
+        def email?(value)
+          value.include?('@')
+        end
+      end
+    end
+
+    include_context 'uses custom predicates'
+  end
+end

data/spec/integration/validation_spec.rb

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,165 @@
+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