dry-validation 0.13.3 → 1.7.0

data/lib/dry/validation/type_specs.rb

@@ -1,70 +0,0 @@
-module Dry
-  module Validation
-    module TypeSpecs
-      def self.extended(klass)
-        super
-        klass.class_eval do
-          setting :input_processor, :noop
-          setting :hash_type, :weak
-          setting :type_map, {}
-        end
-      end
-
-      def build_type_map(type_specs, category = config.input_processor)
-        if type_specs.is_a?(Array)
-          build_array_type(type_specs[0], category)
-        else
-          type_specs.reduce({}) { |res, (name, spec)|
-            res.update(name => resolve_spec(spec, category))
-          }
-        end
-      end
-
-      def build_hash_type(spec = type_map)
-        lookup_type("hash", config.input_processor)
-          .public_send(config.hash_type, spec)
-      end
-
-      def build_array_type(spec, category)
-        member_schema = build_type_map(spec, category)
-        member_type = lookup_type("hash", category)
-          .public_send(config.hash_type, member_schema)
-
-        lookup_type("array", category).of(member_type)
-      end
-
-      def build_sum_type(spec, category)
-        spec
-          .map { |id| id.is_a?(Symbol) ? lookup_type(id, category) : id }
-          .reduce(:|)
-      end
-
-      def resolve_spec(spec, category)
-        case spec
-        when Symbol
-          lookup_type(spec, category)
-        when Hash
-          build_hash_type(spec)
-        when Array
-          if spec.size == 1
-            if spec[0].is_a?(Hash)
-              build_array_type(spec[0], category)
-            else
-              array_member = lookup_type(spec[0], category)
-              lookup_type("array", category).of(array_member)
-            end
-          else
-            build_sum_type(spec, category)
-          end
-        else
-          spec
-        end
-      end
-
-      def lookup_type(name, category)
-        id = "#{category}.#{name}"
-        Types.type_keys.include?(id) ? Types[id] : Types[name.to_s]
-      end
-    end
-  end
-end

data/spec/extensions/monads/result_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe Dry::Validation::Result do
-  before { Dry::Validation.load_extensions(:monads) }
-
-  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?, size?: 2..4) } }
-
-  context 'with valid input' do
-    let(:input) { { name: 'Jane' } }
-
-    describe '#to_monad' do
-      it 'returns a Success value' do
-        monad = result.to_monad
-
-        expect(monad).to be_a Dry::Monads::Result
-        expect(monad).to be_a_success
-        expect(monad.value!).to eql(name: 'Jane')
-      end
-    end
-  end
-
-  context 'with invalid input' do
-    let(:input) { { name: '' } }
-
-    describe '#to_monad' do
-      it 'returns a Failure value' do
-        monad = result.to_monad
-
-        expect(monad).to be_a_failure
-        expect(monad.failure).to eql(name: ['must be filled', 'length must be within 2 - 4'])
-      end
-
-      it 'returns full messages' do
-        monad = result.to_monad(full: true)
-
-        expect(monad).to be_a Dry::Monads::Result
-        expect(monad).to be_a_failure
-        expect(monad.failure).to eql(name: ['name must be filled', 'name length must be within 2 - 4'])
-      end
-    end
-  end
-end

data/spec/extensions/struct/schema_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining schema using dry struct' do
-  before do
-    Dry::Validation.load_extensions(:struct)
-  end
-
-  subject(:schema) do
-    Dry::Validation.Schema do
-      required(:person).filled(Test::Person)
-    end
-  end
-
-  before do
-    class Test::Name < Dry::Struct::Value
-      attribute :given_name, Dry::Types['strict.string']
-      attribute :family_name, Dry::Types['strict.string']
-    end
-
-    class Test::Person < Dry::Struct::Value
-      attribute :name, Test::Name
-    end
-  end
-
-  it 'handles nested structs' do
-    expect(schema.call(person: { name: { given_name: 'Tim', family_name: 'Cooper' } })).to be_success
-  end
-
-  it 'fails when input is not valid' do
-    expect(schema.call(person: { name: { given_name: 'Tim' } }).messages).to eq(
-      person: { name: { family_name: ['is missing', 'must be String'] } }
-    )
-  end
-end

data/spec/fixtures/locales/en.yml

@@ -1,8 +0,0 @@
-en:
-  errors:
-    rules:
-      email:
-        filled?: "Please provide your email"
-      age:
-        gt?: "%{input} must be greater than %{num}"
-    email?: "must be an email"

data/spec/fixtures/locales/pl.yml

@@ -1,22 +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!"
-
-  rules:
-    email:
-      'Adres email'

data/spec/integration/custom_error_messages_spec.rb

@@ -1,54 +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: '', age: 12).messages).to eql(
-          email: ['Please provide your email'], age: ['12 must be greater than 18']
-        )
-
-        expect(schema.(email: '', age: 14).messages).to eql(
-          email: ['Please provide your email'], age: ['14 must be greater than 18']
-        )
-      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
-        required(:age).value(gt?: 18)
-      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
-          required(:age).value(gt?: 18)
-        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

data/spec/integration/injecting_rules_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe 'Schema / Injecting Rules' do
-  subject(:schema) do
-    Dry::Validation.Schema(rules: other.class.rules) do
-      required(:email).maybe
-
-      rule(:email) { value(:login).true? > value(:email).filled? }
-    end
-  end
-
-  let(:other) do
-    Dry::Validation.Schema do
-      required(:login) { |value| value.bool? }
-    end
-  end
-
-  it 'appends rules from another schema' do
-    expect(schema.(login: true, email: 'jane@doe')).to be_success
-    expect(schema.(login: false, email: nil)).to be_success
-    expect(schema.(login: true, email: nil)).to_not be_success
-    expect(schema.(login: nil, email: 'jane@doe')).to_not be_success
-  end
-
-  it 'keeps the original schema rules intact' do
-    expect(other.class.rules.size).to eq(1)
-
-    schema.(login: true, email: 'jane@doe')
-
-    expect(other.class.rules.size).to eq(1)
-  end
-end

data/spec/integration/json/defining_base_schema_spec.rb

@@ -1,41 +0,0 @@
-require 'dry/validation/messages/i18n'
-require 'i18n'
-
-RSpec.describe 'Defining base schema class' do
-  subject(:schema) do
-    Dry::Validation.JSON(BaseSchema) do
-      required(:email).filled(:email?)
-    end
-  end
-
-  before do
-    class BaseSchema < Dry::Validation::Schema
-      configure do |config|
-        config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
-        config.messages = :i18n
-      end
-
-      def email?(value)
-        true
-      end
-
-      define! do
-        required(:name).filled
-      end
-    end
-  end
-
-  after do
-    Object.send(:remove_const, :BaseSchema)
-  end
-
-  it 'inherits predicates' do
-    expect(schema).to respond_to(:email?)
-  end
-
-  it 'inherits rules' do
-    expect(schema.('name' => '').messages).to eql(
-      name: ['must be filled'], email: ['is missing', 'must be an email']
-    )
-  end
-end