dry-validation 0.7.4 → 0.8.0

data/spec/integration/injecting_rules_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe 'Schema / Injecting Rules' do
   subject(:schema) do
     Dry::Validation.Schema(rules: other.class.rules) do
-      key(:email).maybe
+      required(:email).maybe
 
       rule(:email) { value(:login).true? > value(:email).filled? }
     end
@@ -9,7 +9,7 @@ RSpec.describe 'Schema / Injecting Rules' do
 
   let(:other) do
     Dry::Validation.Schema do
-      key(:login) { |value| value.bool? }
+      required(:login) { |value| value.bool? }
     end
   end
 

data/spec/integration/localized_error_messages_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe Dry::Validation, 'with localized messages' do
             config.messages = :i18n
           end
 
-          key(:email) { |email| email.filled? }
+          required(:email) { |email| email.filled? }
         end
       end
 
@@ -38,7 +38,7 @@ RSpec.describe Dry::Validation, 'with localized messages' do
             end
           end
 
-          key(:email) { |email| email.filled? }
+          required(:email) { |email| email.filled? }
         end
       end
 

data/spec/integration/messages/i18n_spec.rb

@@ -30,13 +30,13 @@ RSpec.describe Messages::I18n do
       it 'returns a message for a specific val type' do
         message = messages[:size?, rule: :pages, val_type: String]
 
-        expect(message).to eql("length must be %{num}")
+        expect(message).to eql("length must be %{size}")
       end
 
       it 'returns a message for a specific rule and its default arg type' do
         message = messages[:size?, rule: :pages]
 
-        expect(message).to eql("size must be %{num}")
+        expect(message).to eql("size must be %{size}")
       end
 
       it 'returns a message for a specific rule and its arg type' do
@@ -62,7 +62,7 @@ RSpec.describe Messages::I18n do
       it 'returns a message for a specific rule and its default arg type' do
         message = messages[:size?, rule: :pages, locale: :pl]
 
-        expect(message).to eql("wielkość musi być równa %{num}")
+        expect(message).to eql("wielkość musi być równa %{size}")
       end
 
       it 'returns a message for a specific rule and its arg type' do

data/spec/integration/optional_keys_spec.rb

@@ -4,9 +4,9 @@ RSpec.describe Dry::Validation::Schema do
       Dry::Validation.Schema do
         optional(:email) { |email| email.filled? }
 
-        key(:address) do
-          key(:city, &:filled?)
-          key(:street, &:filled?)
+        required(:address).schema do
+          required(:city, &:filled?)
+          required(:street, &:filled?)
 
           optional(:phone_number) do
             none? | str?

data/spec/integration/schema/array_schema_spec.rb

@@ -1,23 +1,59 @@
 RSpec.describe Dry::Validation::Schema, 'for an array' do
-  subject(:schema) do
-    Dry::Validation.Schema do
-      each do
-        key(:prefix).required
-        key(:value).required
+  context 'without type specs' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        each do
+          schema do
+            required(:prefix).filled
+            required(:value).filled
+          end
+        end
       end
     end
+
+    it 'applies its rules to array input' do
+      result = schema.([{ prefix: 1, value: 123 }, { prefix: 2, value: 456 }])
+
+      expect(result).to be_success
+
+      result = schema.([{ prefix: 1, value: nil }, { prefix: nil, value: 456 }])
+
+      expect(result.messages).to eql(
+        0 => { value: ["must be filled"] },
+        1 => { prefix: ["must be filled"] }
+      )
+    end
   end
 
-  it 'applies its rules to array input' do
-    result = schema.([{ prefix: 1, value: 123 }, { prefix: 2, value: 456 }])
+  context 'with type specs' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
 
-    expect(result).to be_success
+        each do
+          schema do
+            required(:prefix, :int).filled
+            required(:value, :int).filled
+          end
+        end
+      end
+    end
+
+    it 'applies its rules to coerced array input' do
+      result = schema.([{ prefix: 1, value: '123' }, { prefix: 2, value: 456 }])
+
+      expect(result).to be_success
 
-    result = schema.([{ prefix: 1, value: nil }, { prefix: nil, value: 456 }])
+      expect(result.output).to eql(
+        [{ prefix: 1, value: 123 }, { prefix: 2, value: 456 }]
+      )
 
-    expect(result.messages).to eql(
-      0 => { value: ["must be filled"] },
-      1 => { prefix: ["must be filled"] }
-    )
+      result = schema.([{ prefix: 1, value: nil }, { prefix: nil, value: 456 }])
+
+      expect(result.messages).to eql(
+        0 => { value: ["must be filled"] },
+        1 => { prefix: ["must be filled"] }
+      )
+    end
   end
 end

data/spec/integration/schema/check_rules_spec.rb

@@ -50,8 +50,8 @@ RSpec.describe Schema, 'using high-level rules' do
           end
         end
 
-        key(:login).required(:bool?)
-        key(:email).maybe
+        required(:login).filled(:bool?)
+        required(:email).maybe
 
         rule(:email_presence) { value(:login).true?.then(value(:email).filled?) }
 
@@ -83,18 +83,18 @@ RSpec.describe Schema, 'using high-level rules' do
   describe 'with nested schemas' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:command).required(:str?, inclusion?: %w(First Second))
+        required(:command).filled(:str?, included_in?: %w(First Second))
 
-        key(:args).required(:hash?)
+        required(:args).filled(:hash?)
 
         rule(first_args: [:command, :args]) do |command, args|
           command.eql?('First')
-            .then(args.schema { key(:first).required(:bool?) })
+            .then(args.schema { required(:first).filled(:bool?) })
         end
 
         rule(second_args: [:command, :args]) do |command, args|
           command.eql?('Second')
-            .then(args.schema { key(:second).required(:bool?) })
+            .then(args.schema { required(:second).filled(:bool?) })
         end
       end
     end

data/spec/integration/schema/check_with_nested_el_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe 'Check depending on a nested value from a hash' do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:tag).schema do
-        key(:color).schema do
-          key(:value).required(:str?)
+      required(:tag).schema do
+        required(:color).schema do
+          required(:value).filled(:str?)
         end
       end
 

data/spec/integration/schema/check_with_nth_el_spec.rb

@@ -1,7 +1,7 @@
 RSpec.describe 'Check depending on nth element in an array' do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:tags).each(:str?)
+      required(:tags).each(:str?)
 
       rule(red: [[:tags, 0]]) do |value|
         value.eql?('red')

data/spec/integration/schema/each_with_set_spec.rb

@@ -1,9 +1,9 @@
 RSpec.describe 'Schema with each and set rules' do
   subject(:schema) do
     Dry::Validation.Schema do
-      key(:payments).each do
-        key(:method).required(:str?)
-        key(:amount).required(:float?)
+      required(:payments).each do
+        required(:method).filled(:str?)
+        required(:amount).filled(:float?)
       end
     end
   end

data/spec/integration/schema/extending_dsl_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe 'Extending DSL' do
+  it 'allows configuring custom DSL methods' do
+    dsl_ext = Module.new do
+      def maybe_int(name, *predicates, &block)
+        required(name, [:nil, :int]).maybe(:int?, *predicates, &block)
+      end
+    end
+
+    Dry::Validation::Schema.configure do |config|
+      config.dsl_extensions = dsl_ext
+    end
+
+    schema = Dry::Validation.Schema do
+      configure do
+        config.input_processor = :form
+        config.type_specs = true
+      end
+
+      maybe_int(:age)
+    end
+
+    expect(schema.(age: nil)).to be_success
+    expect(schema.(age: 1)).to be_success
+    expect(schema.(age: '1')).to be_success
+    expect(schema.(age: 'foo').messages).to eql(age: ['must be an integer'])
+  end
+end

data/spec/integration/schema/form/explicit_types_spec.rb

@@ -0,0 +1,182 @@
+RSpec.describe Dry::Validation::Schema::Form, 'explicit types' do
+  context 'single type spec without rules' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:age, :int)
+      end
+    end
+
+    it 'uses form coercion' do
+      expect(schema.('age' => '19').to_h).to eql(age: 19)
+    end
+  end
+
+  context 'single type spec with rules' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:age, :int).value(:int?, gt?: 18)
+      end
+    end
+
+    it 'applies rules to coerced value' do
+      expect(schema.(age: 19).messages).to be_empty
+      expect(schema.(age: 18).messages).to eql(age: ['must be greater than 18'])
+    end
+  end
+
+  context 'single type spec with an array' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:nums, [:int])
+      end
+    end
+
+    it 'uses form coercion' do
+      expect(schema.(nums: %w(1 2 3)).to_h).to eql(nums: [1, 2, 3])
+    end
+  end
+
+  context 'sum type spec without rules' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:age, [:nil, :int])
+      end
+    end
+
+    it 'uses form coercion' do
+      expect(schema.('age' => '19').to_h).to eql(age: 19)
+      expect(schema.('age' => '').to_h).to eql(age: nil)
+    end
+  end
+
+  context 'sum type spec with rules' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:age, [:nil, :int]).maybe(:int?, gt?: 18)
+      end
+    end
+
+    it 'applies rules to coerced value' do
+      expect(schema.(age: nil).messages).to be_empty
+      expect(schema.(age: 19).messages).to be_empty
+      expect(schema.(age: 18).messages).to eql(age: ['must be greater than 18'])
+    end
+  end
+
+  context 'using a type object' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+        required(:age, Types::Form::Nil | Types::Form::Int)
+      end
+    end
+
+    it 'uses form coercion' do
+      expect(schema.('age' => '').to_h).to eql(age: nil)
+      expect(schema.('age' => '19').to_h).to eql(age: 19)
+    end
+  end
+
+  context 'nested schema' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+
+        required(:user).schema do
+          required(:email, :string)
+          required(:age, :int)
+
+          required(:address).schema do
+            required(:street, :string)
+            required(:city, :string)
+            required(:zipcode, :string)
+
+            required(:location).schema do
+              required(:lat, :float)
+              required(:lng, :float)
+            end
+          end
+        end
+      end
+    end
+
+    it 'uses form coercion for nested input' do
+      input = {
+        'user' => {
+          'email' => 'jane@doe.org',
+          'age' => '21',
+          'address' => {
+            'street' => 'Street 1',
+            'city' => 'NYC',
+            'zipcode' => '1234',
+            'location' => { 'lat' => '1.23', 'lng' => '4.56' }
+          }
+        }
+      }
+
+      expect(schema.(input).to_h).to eql(
+        user:  {
+          email: 'jane@doe.org',
+          age: 21,
+          address: {
+            street: 'Street 1',
+            city: 'NYC',
+            zipcode:  '1234',
+            location: { lat: 1.23, lng: 4.56 }
+          }
+        }
+      )
+    end
+  end
+
+  context 'nested schema with arrays' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        configure { config.type_specs = true }
+
+        required(:song).schema do
+          required(:title, :string)
+
+          required(:tags).each do
+            schema do
+              required(:name, :string)
+            end
+          end
+        end
+      end
+    end
+
+    it 'fails to coerce gracefuly' do
+      result = schema.(song: nil)
+
+      expect(result.messages).to eql(song: ['must be a hash'])
+      expect(result.to_h).to eql(song: nil)
+
+      result = schema.(song: { tags: nil })
+
+      expect(result.messages).to eql(song: { tags: ['must be an array'] })
+      expect(result.to_h).to eql(song: { tags: nil })
+    end
+
+    it 'uses form coercion for nested input' do
+      input = {
+        'song' => {
+          'title' => 'dry-rb is awesome lala',
+          'tags' => [{ 'name' => 'red' }, { 'name' => 'blue' }]
+        }
+      }
+
+      expect(schema.(input).to_h).to eql(
+        song: {
+          title: 'dry-rb is awesome lala',
+          tags: [{ name: 'red' }, { name: 'blue' }]
+        }
+      )
+    end
+  end
+end

data/spec/integration/schema/form_spec.rb

@@ -1,17 +1,23 @@
 RSpec.describe Dry::Validation::Schema::Form, 'defining a schema' do
   subject(:schema) do
     Dry::Validation.Form do
-      key(:email).required
+      configure do
+        def email?(value)
+          true
+        end
+      end
+
+      required(:email).filled
 
-      key(:age).maybe(:int?, gt?: 18)
+      required(:age).maybe(:int?, gt?: 18)
 
-      key(:address).schema do
-        key(:city).required
-        key(:street).required
+      required(:address).schema do
+        required(:city).filled
+        required(:street).filled
 
-        key(:loc).schema do
-          key(:lat).required(:float?)
-          key(:lng).required(:float?)
+        required(:loc).schema do
+          required(:lat).filled(:float?)
+          required(:lng).filled(:float?)
         end
       end
 
@@ -20,12 +26,6 @@ RSpec.describe Dry::Validation::Schema::Form, 'defining a schema' do
       optional(:phone_number).maybe(:int?, gt?: 0)
 
       rule(:email_valid) { value(:email).email? }
-
-      configure do
-        def email?(value)
-          true
-        end
-      end
     end
   end
 
@@ -118,12 +118,84 @@ RSpec.describe Dry::Validation::Schema::Form, 'defining a schema' do
     end
   end
 
+  describe 'with an each and nested schema' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        required(:items).each do
+          schema do
+            required(:title).filled(:str?)
+          end
+        end
+      end
+    end
+
+    it 'passes when each element passes schema check' do
+      expect(schema.(items: [{ title: 'Foo' }])).to be_success
+    end
+
+    it 'fails when one or more elements did not pass schema check' do
+      expect(schema.(items: [{ title: 'Foo' }, { title: :Foo }]).messages).to eql(
+        items: { 1 => { title: ['must be a string'] } }
+      )
+    end
+  end
+
+  describe 'symbolizing keys when coercion fails' do
+    subject(:schema) do
+      Dry::Validation.Form do
+        required(:email).value(size?: 8..60)
+        required(:birthdate).value(:date?)
+        required(:age).value(:int?, gt?: 23)
+        required(:tags).maybe(max_size?: 3)
+      end
+    end
+
+    let(:tags) { %(al b c) }
+
+    it 'symbolizes keys and coerces values' do
+      result = schema.(
+        'email' => 'jane@doe.org',
+        'birthdate' => '2001-02-03',
+        'age' => '24',
+        'tags' => tags
+      ).to_h
+
+      expect(result.to_h).to eql(
+        email: 'jane@doe.org',
+        birthdate: Date.new(2001, 2, 3),
+        age: 24,
+        tags: tags
+      )
+    end
+
+    it 'symbolizes keys even when coercion fails' do
+      result = schema.(
+        'email' => 'jane@doe.org',
+        'birthdate' => '2001-sutin-03',
+        'age' => ['oops'],
+        'tags' => nil
+      )
+
+      expect(result.to_h).to eql(
+        email: 'jane@doe.org',
+        birthdate: '2001-sutin-03',
+        age: ['oops'],
+        tags: nil
+      )
+
+      expect(result.messages).to eql(
+        birthdate: ['must be a date'],
+        age: ['must be an integer', 'must be greater than 23']
+      )
+    end
+  end
+
   describe 'with nested schema in a high-level rule' do
     subject(:schema) do
       Dry::Validation.Form do
-        key(:address).maybe(:hash?)
+        required(:address).maybe(:hash?)
 
-        key(:delivery).required(:bool?)
+        required(:delivery).filled(:bool?)
 
         rule(address: [:delivery, :address]) do |delivery, address|
           delivery.true?.then(address.schema(AddressSchema))
@@ -133,8 +205,8 @@ RSpec.describe Dry::Validation::Schema::Form, 'defining a schema' do
 
     before do
       AddressSchema = Dry::Validation.Form do
-        key(:city).required
-        key(:zipcode).required(:int?)
+        required(:city).filled
+        required(:zipcode).filled(:int?)
       end
     end