dry-validation 0.13.3 → 1.7.0

data/spec/integration/schema/xor_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe 'Schema with xor rules' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      configure do
-        def self.messages
-          Messages.default.merge(
-            en: { errors: { be_reasonable: 'you cannot eat cake and have cake!' } }
-          )
-        end
-      end
-
-      required(:eat_cake).filled
-
-      required(:have_cake).filled
-
-      rule(be_reasonable: %i[eat_cake have_cake]) do |ec, hc|
-        ec.eql?('yes!') ^ hc.eql?('yes!')
-      end
-    end
-  end
-
-  describe '#messages' do
-    it 'passes when only one option is selected' do
-      messages = schema.(eat_cake: 'yes!', have_cake: 'no!').messages[:be_reasonable]
-
-      expect(messages).to be(nil)
-    end
-
-    it 'fails when both options are selected' do
-      expect(schema.(eat_cake: 'yes!', have_cake: 'yes!').messages).to eql(
-        be_reasonable: ['you cannot eat cake and have cake!']
-      )
-    end
-  end
-end

data/spec/integration/schema_builders_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe 'Building schemas' do
-  describe 'Dry::Validation.Schema' do
-    it 'builds a schema class with custom predicate set' do
-      predicates = Module.new do
-        include Dry::Logic::Predicates
-
-        def zomg?(*)
-          true
-        end
-      end
-
-      schema = Dry::Validation.Schema(predicates: predicates, build: false)
-
-      expect(schema.predicates[:key?]).to be_a(Method)
-    end
-  end
-end

data/spec/integration/schema_spec.rb

@@ -1,173 +0,0 @@
-RSpec.describe Dry::Validation::Schema, 'defining key-based schema' do
-  describe 'with a flat structure' do
-    subject(:schema) do
-      Dry::Validation.Schema do
-        configure do
-          config.input_processor = :params
-          config.type_specs = true
-        end
-
-        required(:email, :string).filled
-        required(:age, [:nil, :integer]) { none? | (int? & gt?(18)) }
-      end
-    end
-
-    it 'passes when input is valid' do
-      expect(schema.(email: 'jane@doe', age: 19)).to be_success
-      expect(schema.(email: 'jane@doe', age: nil)).to be_success
-    end
-
-    it 'fails when input is not valid' do
-      expect(schema.(email: 'jane@doe', age: 17)).to_not be_success
-    end
-
-    it 'returns result which quacks like hash' do
-      input = { email: 'jane@doe', age: 19 }
-      result = schema.(input)
-
-      expect(result[:email]).to eql('jane@doe')
-      expect(Hash[result]).to eql(input)
-
-      expect(result.to_a).to eql([[:email, 'jane@doe'], [:age, 19]])
-    end
-
-    describe '#type_map' do
-      it 'returns key=>type map' do
-        expect(schema.type_map).to eql(
-          email: Types::String, age: Types::Params::Nil | Types::Params::Integer
-        )
-      end
-
-      it 'uses type_map for input processor when it is not empty' do
-        expect(schema.(email: 'jane@doe.org', age: '18').to_h).to eql(
-          email: 'jane@doe.org', age: 18
-        )
-      end
-    end
-  end
-
-  describe 'with nested structures' do
-    subject(:schema) do
-      class Test::CountrySchema
-        def self.schema
-          Dry::Validation.Schema do
-            required(:name).filled
-            required(:code).filled
-          end
-        end
-      end
-
-      Dry::Validation.Schema do
-        required(:email).filled
-
-        required(:age).maybe(:int?, gt?: 18)
-
-        required(:address).schema do
-          required(:city).filled(min_size?: 3)
-
-          required(:street).filled
-
-          required(:country).schema(Test::CountrySchema)
-        end
-
-        required(:phone_numbers).each(:str?)
-      end
-    end
-
-    let(:input) 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(schema.(input.merge(email: '')).messages).to eql(
-          email: ['must be filled']
-        )
-      end
-    end
-
-    describe '#call' do
-      it 'passes when attributes are valid' do
-        expect(schema.(input)).to be_success
-      end
-
-      it 'validates presence of an email and min age value' do
-        expect(schema.(input.merge(email: '', age: 18)).messages).to eql(
-          email: ['must be filled'], age: ['must be greater than 18']
-        )
-      end
-
-      it 'validates presence of the email key and type of age value' do
-        attrs = {
-          name: 'Jane',
-          age: '18',
-          address: input[:address], phone_numbers: input[:phone_numbers]
-        }
-
-        expect(schema.(attrs).messages).to eql(
-          email: ['is missing'],
-          age: ['must be an integer', 'must be greater than 18']
-        )
-      end
-
-      it 'validates presence of the address and phone_number keys' do
-        attrs = { email: 'jane@doe.org', age: 19 }
-
-        expect(schema.(attrs).messages).to eql(
-          address: ['is missing'], phone_numbers: ['is missing']
-        )
-      end
-
-      it 'validates presence of keys under address and min size of the city value' do
-        attrs = input.merge(address: { city: 'NY' })
-
-        expect(schema.(attrs).messages).to eql(
-          address: {
-            street: ['is missing'],
-            country: ['is missing'],
-            city: ['size cannot be less than 3']
-          }
-        )
-      end
-
-      it 'validates address type' do
-        expect(schema.(input.merge(address: 'totally not a hash')).messages).to eql(
-          address: ['must be a hash']
-        )
-      end
-
-      it 'validates address code and name values' do
-        attrs = input.merge(
-          address: input[:address].merge(country: { code: 'US', name: '' })
-        )
-
-        expect(schema.(attrs).messages).to eql(
-          address: { country: { name: ['must be filled'] } }
-        )
-      end
-
-      it 'validates each phone number' do
-        attrs = input.merge(phone_numbers: ['123', 312])
-
-        expect(schema.(attrs).messages).to eql(
-          phone_numbers: { 1 => ['must be a string'] }
-        )
-      end
-    end
-  end
-
-  context 'nested keys' do
-    it 'raises error when defining nested keys without `schema` block`' do
-      expect {
-        Dry::Validation.Schema { required(:foo).value { required(:bar).value(:str?) } }
-      }.to raise_error(ArgumentError, /required/)
-    end
-  end
-end

data/spec/shared/message_compiler.rb

@@ -1,11 +0,0 @@
-RSpec.shared_context :message_compiler do
-  subject(:compiler) { Dry::Validation::MessageCompiler.new(messages) }
-
-  let(:messages) do
-    Dry::Validation::Messages.default
-  end
-
-  let(:result) do
-    compiler.public_send(visitor, node)
-  end
-end

data/spec/shared/predicate_helper.rb

@@ -1,15 +0,0 @@
-RSpec.shared_context 'predicate helper' do
-  def p(name, *args)
-    Dry::Logic::Rule::Predicate.new(predicates[name], args: args).to_ast
-  end
-
-  let!(:predicates) do
-    Module.new {
-      include Dry::Logic::Predicates
-
-      def self.email?(value)
-        true
-      end
-    }
-  end
-end

data/spec/shared/rule_compiler.rb

@@ -1,8 +0,0 @@
-require 'dry/logic/rule_compiler'
-require 'dry/logic/predicates'
-
-RSpec.shared_context 'rule compiler' do
-  let(:rule_compiler) do
-    Dry::Logic::RuleCompiler.new(Dry::Logic::Predicates)
-  end
-end

data/spec/spec_helper.rb

@@ -1,62 +0,0 @@
-if ENV['COVERAGE'] == 'true' && RUBY_ENGINE == 'ruby' && RUBY_VERSION == '2.3.1'
-  require "simplecov"
-  SimpleCov.start do
-    add_filter '/spec/'
-  end
-end
-
-begin
-  require 'pry'
-  require 'pry-byebug'
-rescue LoadError
-end
-
-require 'dry-validation'
-require 'dry/core/constants'
-require 'ostruct'
-
-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
-
-module Types
-  include Dry::Types.module
-end
-
-Dry::Validation::Deprecations.configure do |config|
-  config.logger = Logger.new(SPEC_ROOT.join('../log/deprecations.log'))
-end
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.warnings = true
-
-  config.after do
-    if defined?(I18n)
-      I18n.load_path = Dry::Validation.messages_paths.dup
-      I18n.backend.reload!
-    end
-  end
-
-  config.include PredicatesIntegration
-
-  config.before do
-    module Test
-      def self.remove_constants
-        constants.each { |const| remove_const(const)  }
-        self
-      end
-    end
-
-    Dry::Validation::Messages::Abstract.instance_variable_set('@cache', nil)
-    Dry::Validation::Messages::YAML.instance_variable_set('@cache', nil)
-    Dry::Validation::Messages::I18n.instance_variable_set('@cache', nil) if defined?(I18n)
-  end
-
-  config.after do
-    Object.send(:remove_const, Test.remove_constants.name)
-  end
-end

data/spec/support/define_struct.rb

@@ -1,25 +0,0 @@
-module DefineStruct
-  def from_hash(hash = {})
-    values = members.map do |attr|
-      val = hash[attr]
-      val.is_a?(Hash) ? define_struct(*val.keys).from_hash(val) : val
-    end
-    new(*values)
-  end
-
-  def define_struct(*attrs)
-    Struct.new(*attrs) do
-      extend DefineStruct
-    end
-  end
-end
-
-def def_struct(*attrs)
-  Struct.new(*attrs) do
-    extend DefineStruct
-  end
-end
-
-def struct_from_hash(hash)
-  def_struct(*hash.keys).from_hash(hash)
-end

data/spec/support/matchers.rb

@@ -1,38 +0,0 @@
-require 'rspec/expectations'
-
-RSpec::Matchers.define :be_successful do
-  match do |actual|
-    actual.success? &&
-      actual.messages.empty?
-  end
-
-  failure_message do |actual|
-    "expected that #{actual.inspect} would be successful"
-  end
-
-  failure_message_when_negated do |actual|
-    "expected that #{actual.inspect} would NOT be successful"
-  end
-end
-
-RSpec::Matchers.define :be_failing do |messages|
-  match do |actual|
-    messages = case messages
-               when Hash
-                 messages
-               else
-                 Array(messages)
-               end
-
-    !actual.success? &&
-      actual.messages.fetch(:foo) == messages
-  end
-
-  failure_message do |actual|
-    "expected that #{actual.inspect} would be failing (#{messages.inspect})"
-  end
-
-  failure_message_when_negated do |actual|
-    "expected that #{actual.inspect} would NOT be failing"
-  end
-end

data/spec/support/mutant.rb

@@ -1,9 +0,0 @@
-module Mutant
-  class Selector
-    class Expression < self
-      def call(_subject)
-        integration.all_tests
-      end
-    end
-  end
-end

data/spec/support/predicates_integration.rb

@@ -1,7 +0,0 @@
-module PredicatesIntegration
-  private
-
-  def result
-    schema.(input)
-  end
-end

data/spec/unit/input_processor_compiler/json_spec.rb

@@ -1,283 +0,0 @@
-RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
-  subject(:compiler) { Dry::Validation::InputProcessorCompiler::JSON.new }
-
-  include_context 'predicate helper'
-
-  it 'supports arbitrary types via type?(const) => "json.const"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [:key, [:age, p(:type?, Integer)]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => 21]).to eql(age: 21)
-  end
-
-  it 'supports arbitrary types via type?(conts)' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :admin)],
-          [:key, [:admin, p(:type?, 'Bool')]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['admin' => false]).to eql(admin: false)
-  end
-
-  it 'supports str? => "string"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :email)],
-          [
-            :and, [
-              [:key, [:email, p(:str?, [])]],
-              [:key, [:email, p(:filled?, [])]]
-            ]
-          ]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['email' => 'jane@doe.org']).to eql(email: 'jane@doe.org')
-  end
-
-  it 'supports int? => "int"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [:key, [:age, p(:int?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => 21]).to eql(age: 21)
-  end
-
-  it 'supports bool? => "bool"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :admin)],
-          [:key, [:admin, p(:bool?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['admin' => true]).to eql(admin: true)
-    expect(input_type['admin' => false]).to eql(admin: false)
-  end
-
-  it 'supports none? => "int"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :age)],
-          [
-            :or, [
-              [:key, [:age, p(:none?, [])]],
-              [:key, [:age, p(:int?, [])]],
-            ]
-          ]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['age' => '']).to eql(age: nil)
-    expect(input_type['age' => 21]).to eql(age: 21)
-  end
-
-  it 'supports float? => "float"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :lat)],
-          [:key, [:lat, p(:float?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['lat' => 21.12]).to eql(lat: 21.12)
-  end
-
-  it 'supports decimal? => "json.decimal"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :lat)],
-          [:key, [:lat, p(:decimal?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['lat' => 21.12]).to eql(lat: 21.12.to_d)
-  end
-
-  it 'supports date? => "json.date"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:date?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23']).to eql(bday: Date.new(2012, 1, 23))
-  end
-
-  it 'supports date_time? => "json.date_time"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:date_time?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23 11:07']).to eql(bday: DateTime.new(2012, 1, 23, 11, 7))
-  end
-
-  it 'supports time? => "json.time"' do
-    rule_ast = [
-      [
-        :and,
-        [
-          [:val, p(:key?, :bday)],
-          [:key, [:bday, p(:time?, [])]],
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['bday' => '2012-01-23 11:07']).to eql(bday: Time.new(2012, 1, 23, 11, 7))
-  end
-
-  it 'supports each rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :author)],
-          [:set, [
-            [:and, [
-              [:val, p(:key?, :books)],
-              [
-                :each, [
-                  :set, [
-                    [
-                      :and, [
-                        [:val, p(:key?, :published)],
-                        [:key, [:published, p(:bool?, [])]]
-                      ]
-                    ]
-                  ]
-                ]
-              ]
-            ]]
-          ]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type['author' => { 'books' => [{ 'published' => true }] }]).to eql(
-      author: { books: [published: true] }
-    )
-
-    expect(input_type['author' => { 'books' => [{ 'published' => false }] }]).to eql(
-      author: { books: [published: false] }
-    )
-  end
-
-  it 'supports array? with an each rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :ids)],
-          [:and, [
-            [:key, [:ids, p(:array?, [])]],
-            [:each, [:val, p(:int?, [])]]
-          ]]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type.('ids' => 'oops')).to eql(ids: 'oops')
-
-    expect(input_type.('ids' => [1, 2, 3])).to eql(ids: [1, 2, 3])
-  end
-
-  it 'supports hash? with a set rule' do
-    rule_ast = [
-      [
-        :and, [
-          [:val, p(:key?, :address)],
-          [
-            :and, [
-              [:key, [:address, p(:hash?, [])]],
-              [
-                :set, [
-                  [
-                    :and, [
-                      [:val, p(:key?, :street)],
-                      [:key, [:street, p(:filled?, [])]]
-                    ]
-                  ]
-                ]
-              ]
-            ]
-          ]
-        ]
-      ]
-    ]
-
-    input_type = compiler.(rule_ast)
-
-    expect(input_type.('address' => 'oops')).to eql(address: 'oops')
-
-    expect(input_type.('address' => { 'street' => 'ok' })).to eql(
-      address: { street: 'ok' }
-    )
-  end
-end