dry-validation 0.12.0 → 1.6.0

data/spec/fixtures/locales/pl.yml

@@ -1,18 +0,0 @@
-pl:
-  errors:
-    filled?: "nie może być pusty"
-    size?:
-      arg:
-        default: "wielkość musi być równa %{size}"
-        range: "wielkość musi być między %{size_left} a %{size_right}"
-      value:
-        string:
-          arg:
-            default: "wielkość musi być równa %{size}"
-    rules:
-      email:
-        filled?: "Proszę podać adres email"
-      user:
-        rules:
-          email:
-            filled?: "Hej user! Dawaj ten email no!"

data/spec/integration/custom_error_messages_spec.rb

@@ -1,48 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe Dry::Validation do
-  shared_context 'schema with customized messages' do
-    describe '#messages' do
-      it 'returns compiled error messages' do
-        expect(schema.(email: '').messages).to eql(
-          email: ['Please provide your email']
-        )
-      end
-    end
-  end
-
-  context 'yaml' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        end
-
-        required(:email, &:filled?)
-      end
-    end
-
-    include_context 'schema with customized messages'
-  end
-
-  context 'i18n' do
-    context 'with custom messages set globally' do
-      before do
-        I18n.load_path << SPEC_ROOT.join('fixtures/locales/en.yml')
-        I18n.backend.load_translations
-      end
-
-      subject(:schema) do
-        Dry::Validation.Schema do
-          configure do
-            config.messages = :i18n
-          end
-
-          required(:email, &:filled?)
-        end
-      end
-
-      include_context 'schema with customized messages'
-    end
-  end
-end

data/spec/integration/custom_predicates_spec.rb

@@ -1,228 +0,0 @@
-# -*- coding: utf-8 -*-
-RSpec.describe Dry::Validation do
-  shared_context 'uses custom predicates' do
-    it 'uses provided custom predicates' do
-      expect(schema.(email: 'jane@doe')).to be_success
-
-      expect(schema.(email: nil).messages).to eql(
-        email: ['must be filled', 'must be a valid email']
-      )
-
-      expect(schema.(email: 'jane').messages).to eql(
-        email: ['must be a valid email']
-      )
-    end
-  end
-
-  let(:base_class) do
-    Class.new(Dry::Validation::Schema) do
-      def self.messages
-        Dry::Validation::Messages.default.merge(
-          en: { errors: { email?: 'must be a valid email' } }
-        )
-      end
-    end
-  end
-
-  describe 'defining schema with custom predicates container' do
-    before do
-      module Test
-        module Predicates
-          include Dry::Logic::Predicates
-
-          def self.email?(input)
-            input.include?('@') # for the lols
-          end
-        end
-      end
-    end
-
-    context 'when configured globally' do
-      subject(:schema) do
-        Dry::Validation.Schema(base_class) do
-          required(:email) { filled? & email? }
-        end
-      end
-
-      before do
-        Dry::Validation::Schema.predicates(Test::Predicates)
-      end
-
-      after do
-        # HACK: reset global predicates configuration
-        Dry::Validation::Schema.configure do |config|
-          config.predicates = Dry::Logic::Predicates
-        end
-      end
-
-      include_context 'uses custom predicates'
-    end
-
-    context 'when configured locally' do
-      subject(:schema) do
-        Dry::Validation.Schema(base_class) do
-          configure do
-            predicates(Test::Predicates)
-          end
-
-          required(:email) { filled? & email? }
-        end
-      end
-
-      include_context 'uses custom predicates'
-    end
-  end
-
-  describe 'defining schema with custom predicate methods' do
-    subject(:schema) do
-      Dry::Validation.Schema(base_class) do
-        configure do
-          def email?(value)
-            value.include?('@')
-          end
-        end
-
-        required(:email) { filled? & email? }
-      end
-    end
-
-    include_context 'uses custom predicates'
-  end
-
-  describe 'custom predicate which requires an arbitrary dependency' do
-    subject(:schema) do
-      Dry::Validation.Schema(base_class) do
-        configure do
-          option :email_check
-
-          def email?(value)
-            email_check.(value)
-          end
-        end
-
-        required(:email).filled(:email?)
-      end
-    end
-
-    it 'uses injected dependency for the custom predicate' do
-      email_check = -> input { input.include?('@') }
-
-      expect(schema.with(email_check: email_check).(email: 'foo').messages).to eql(
-        email: ['must be a valid email']
-      )
-    end
-  end
-
-  it 'raises an error when message is missing' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def email?(value)
-          false
-        end
-      end
-
-      required(:email).filled(:email?)
-    end
-
-    expect { schema.(email: 'foo').messages }.to raise_error(
-      Dry::Validation::MissingMessageError, /email/
-    )
-  end
-
-  it 'works with custom predicate args' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: { errors: { fav_number?: 'must be %{expected}' } }
-          )
-        end
-        def fav_number?(expected, current)
-          current == expected
-        end
-      end
-
-      required(:foo) { fav_number?(23) }
-    end
-
-    expect(schema.(foo: 20).messages).to eql(
-      foo: ['must be 23']
-    )
-
-  end
-
-  it 'works when no predicate args' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: { errors: { with_no_args?: 'is always false' } }
-          )
-        end
-
-        def with_no_args?
-          false
-        end
-      end
-
-      required(:email).filled(:with_no_args?)
-    end
-
-    expect(schema.(email: 'foo').messages).to eql(
-      email: ['is always false']
-    )
-  end
-
-  it 'works with nested schemas' do
-    schema = Dry::Validation.Schema do
-      configure do
-        def ok?(_value)
-          true
-        end
-      end
-
-      required(:foo).schema do
-        required(:bar).value(:ok?)
-      end
-    end
-
-    expect(schema.(foo: { bar: "1" })).to be_success
-  end
-
-  it 'works with interpolation of messages' do
-    schema = Dry::Validation.Schema do
-      configure do
-        option :categories, []
-
-        def self.messages
-          Dry::Validation::Messages.default.merge(
-            en: {
-              errors: {
-                valid_category?: 'must be one of the categories: %{categories}'
-              }
-            },
-            pl: {
-              errors: {
-                valid_category?: 'musi być jedną z: %{categories}'
-              }
-            }
-          )
-        end
-
-        def valid_category?(categories, value)
-          categories.include?(value)
-        end
-      end
-
-      required(:category).filled(valid_category?: categories)
-    end.with(categories: %w(foo bar))
-
-    expect(schema.(category: 'baz').messages).to eql(
-      category: ['must be one of the categories: foo, bar']
-    )
-
-    expect(schema.(category: 'baz').messages(locale: :pl)).to eql(
-      category: ['musi być jedną z: foo, bar']
-    )
-  end
-end

data/spec/integration/hints_spec.rb

@@ -1,170 +0,0 @@
-require 'dry/validation/messages/i18n'
-
-RSpec.describe 'Validation hints' do
-  shared_context '#messages' do
-    it 'provides hints for additional rules that were not checked' do
-      expect(schema.(age: '17').messages).to eql(
-        age: ['must be an integer', 'must be greater than 18']
-      )
-    end
-
-    it 'skips type-check rules' do
-      expect(schema.(age: 17).messages).to eql(
-        age: ['must be greater than 18']
-      )
-    end
-  end
-
-  context 'with yaml messages' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).maybe(:int?, gt?: 18)
-      end
-    end
-
-    include_context '#messages'
-  end
-
-  context 'with i18n messages' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure { configure { |c| c.messages = :i18n } }
-
-        required(:age).maybe(:int?, gt?: 18)
-      end
-    end
-
-    include_context '#messages'
-  end
-
-  context 'when type expectation is specified' do
-    subject(:schema)  do
-      Dry::Validation.Schema do
-        required(:email).filled
-        required(:name).filled(:str?, size?: 5..25)
-      end
-    end
-
-    it 'infers message for specific type' do
-      expect(schema.(email: 'jane@doe', name: 'HN').messages).to eql(
-        name: ['length must be within 5 - 25']
-      )
-    end
-  end
-
-  context 'when predicate failed and there is a corresponding hint generated' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:age).value(lt?: 23)
-      end
-    end
-
-    it 'provides only failure error message' do
-      result = schema.call(age: 23)
-      expect(result.messages).to eql(age: ['must be less than 23'])
-    end
-  end
-
-  context 'with a nested schema with same rule names' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:code).filled(:str?, eql?: 'foo')
-
-        required(:nested).schema do
-          required(:code).filled(:str?, eql?: 'bar')
-        end
-      end
-    end
-
-    it 'provides error messages' do
-      result = schema.call(code: 'x', nested: { code: 'y' })
-
-      expect(result.messages).to eql(
-        code: ['must be equal to foo'],
-        nested: {
-          code: ['must be equal to bar']
-        }
-      )
-    end
-
-    it 'provides hints' do
-      result = schema.call(code: '', nested: { code: '' })
-
-      expect(result.messages).to eql(
-        code: ['must be filled', 'must be equal to foo'],
-        nested: {
-          code: ['must be filled', 'must be equal to bar']
-        }
-      )
-    end
-  end
-
-  context 'with an each rule' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:nums).each(:int?, gt?: 0)
-      end
-    end
-
-    it 'provides hints for each element' do
-      expect(schema.(nums: [1, 'foo', 0]).messages).to eql(
-        nums: {
-          1 => ['must be an integer', 'must be greater than 0'],
-          2 => ['must be greater than 0']
-        }
-      )
-    end
-  end
-
-  context 'with a format? predicate' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        required(:name).value(size?: 2, format?: /xy/)
-      end
-    end
-
-    it 'skips hints' do
-      expect(schema.(name: 'x').messages[:name]).to_not include('is in invalid format')
-      expect(schema.(name: 'ab').messages[:name]).to include('is in invalid format')
-    end
-  end
-
-  context 'when the message uses input value' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          def self.messages
-            Messages.default.merge(
-              en: {
-                errors: {
-                  blue?: {
-                    failure: '%{value} is not equal to blue',
-                    hint: 'must be equal to blue'
-                  }
-                }
-              }
-            )
-          end
-
-          def blue?(value)
-            value == 'blue'
-          end
-        end
-
-        required(:pill).filled(:blue?)
-      end
-    end
-
-    it 'provides a correct failure message' do
-      expect(schema.(pill: 'red').messages).to eql(
-        pill: ['red is not equal to blue']
-      )
-    end
-
-    it 'provides a correct hint' do
-      expect(schema.(pill: nil).messages).to eql(
-        pill: ['must be filled', 'must be equal to blue']
-      )
-    end
-  end
-end