dry-validation 0.7.4 → 0.8.0

data/spec/integration/schema/xor_spec.rb

@@ -9,9 +9,9 @@ RSpec.describe 'Schema with xor rules' do
         end
       end
 
-      key(:eat_cake).required
+      required(:eat_cake).filled
 
-      key(:have_cake).required
+      required(:have_cake).filled
 
       rule(:be_reasonable) do
         value(:eat_cake).eql?('yes!') ^ value(:have_cake).eql?('yes!')

data/spec/integration/schema_builders_spec.rb

@@ -0,0 +1,15 @@
+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
+
+        predicate(:zomg?) { true }
+      end
+
+      schema = Dry::Validation.Schema(predicates: predicates, build: false)
+
+      expect(schema.predicates.key?(:zomg?)).to be(true)
+    end
+  end
+end

data/spec/integration/schema_spec.rb

@@ -2,8 +2,13 @@ RSpec.describe Dry::Validation::Schema, 'defining key-based schema' do
   describe 'with a flat structure' do
     subject(:schema) do
       Dry::Validation.Schema do
-        key(:email).required
-        key(:age) { none? | (int? & gt?(18)) }
+        configure do
+          config.input_processor = :form
+          config.type_specs = true
+        end
+
+        required(:email, :string).filled
+        required(:age, [:nil, :int]) { none? | (int? & gt?(18)) }
       end
     end
 
@@ -25,27 +30,47 @@ RSpec.describe Dry::Validation::Schema, 'defining key-based schema' do
 
       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::Form::Nil | Types::Form::Int
+        )
+      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 CountrySchema
+        def self.schema
+          Dry::Validation.Schema do
+            required(:name).filled
+            required(:code).filled
+          end
+        end
+      end
+
       Dry::Validation.Schema do
-        key(:email).required
+        required(:email).filled
 
-        key(:age).maybe(:int?, gt?: 18)
+        required(:age).maybe(:int?, gt?: 18)
 
-        key(:address).schema do
-          key(:city).required(min_size?: 3)
+        required(:address).schema do
+          required(:city).filled(min_size?: 3)
 
-          key(:street).required
+          required(:street).filled
 
-          key(:country).schema do
-            key(:name).required
-            key(:code).required
-          end
+          required(:country).schema(CountrySchema)
         end
 
-        key(:phone_numbers).each(:str?)
+        required(:phone_numbers).each(:str?)
       end
     end
 

data/spec/shared/predicate_helper.rb

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

data/spec/spec_helper.rb

@@ -19,6 +19,14 @@ 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!
 
@@ -28,4 +36,6 @@ RSpec.configure do |config|
       I18n.backend.reload!
     end
   end
+
+  config.include PredicatesIntegration
 end

data/spec/support/matchers.rb

@@ -0,0 +1,38 @@
+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/predicates_integration.rb

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

data/spec/unit/hint_compiler_spec.rb

@@ -3,18 +3,20 @@ require 'dry/validation/hint_compiler'
 RSpec.describe HintCompiler, '#call' do
   subject(:compiler) { HintCompiler.new(Messages.default, rules: rules) }
 
+  include_context 'predicate helper'
+
   let(:rules) do
     [
       [
         :and, [
-          [:val, [:predicate, [:key?, [:age]]]],
+          [:val, p(:key?, :age)],
           [
             :or, [
-              [:key, [:age, [:predicate, [:none?, []]]]],
+              [:key, [:age, p(:none?)]],
               [
                 :and, [
-                  [:key, [:age, [:predicate, [:int?, []]]]],
-                  [:key, [:age, [:predicate, [:gt?, [18]]]]]
+                  [:key, [:age, p(:int?)]],
+                  [:key, [:age, p(:gt?, 18)]]
                 ]
               ]
             ]
@@ -23,14 +25,14 @@ RSpec.describe HintCompiler, '#call' do
       ],
       [
         :and, [
-          [:val, [:predicate, [:attr?, [:height]]]],
+          [:val, p(:key?, :height)],
           [
             :or, [
-              [:attr, [:height, [:predicate, [:none?, []]]]],
+              [:attr, [:height, p(:none?)]],
               [
                 :and, [
-                  [:attr, [:height, [:predicate, [:int?, []]]]],
-                  [:attr, [:height, [:predicate, [:gt?, [180]]]]]
+                  [:key, [:height, p(:int?)]],
+                  [:key, [:height, p(:gt?, 180)]]
                 ]
               ]
             ]

data/spec/unit/input_processor_compiler/form_spec.rb

@@ -1,29 +1,31 @@
 RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
   subject(:compiler) { Dry::Validation::InputProcessorCompiler::Form.new }
 
+  include_context 'predicate helper'
+
   let(:rule_ast) do
     [
       [
         :and, [
-          [:val, [:predicate, [:key?, [:email]]]],
+          [:val, p(:key?, :email)],
           [
             :and, [
-              [:key, [:email, [:predicate, [:str?, []]]]],
-              [:key, [:email, [:predicate, [:filled?, []]]]]
+              [:key, [:email, p(:str?)]],
+              [:key, [:email, p(:filled?)]]
             ]
           ]
         ]
       ],
       [
         :and, [
-          [:val, [:predicate, [:key?, [:age]]]],
+          [:val, p(:key?, :age)],
           [
             :or, [
-              [:key, [:age, [:predicate, [:none?, []]]]],
+              [:key, [:age, p(:none?)]],
               [
                 :and, [
-                  [:key, [:age, [:predicate, [:int?, []]]]],
-                  [:key, [:age, [:predicate, [:filled?, []]]]]
+                  [:key, [:age, p(:int?)]],
+                  [:key, [:age, p(:filled?)]]
                 ]
               ]
             ]
@@ -32,8 +34,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       ],
       [
         :and, [
-          [:val, [:predicate, [:key?, [:address]]]],
-          [:key, [:address, [:predicate, [:str?, []]]]]
+          [:val, p(:key?, :address)],
+          [:key, [:address, p(:str?)]]
         ]
       ]
     ]
@@ -56,8 +58,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:age]]]],
-          [:key, [:age, [:predicate, [:type?, [Fixnum]]]]]
+          [:val, p(:key?, :age)],
+          [:key, [:age, p(:type?, Fixnum)]]
         ]
       ]
     ]
@@ -72,8 +74,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:admin]]]],
-          [:key, [:admin, [:predicate, [:type?, ['Form::Bool']]]]]
+          [:val, p(:key?, :admin)],
+          [:key, [:admin, p(:type?, 'Form::Bool')]]
         ]
       ]
     ]
@@ -88,8 +90,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:age]]]],
-          [:key, [:age, [:predicate, [:int?, []]]]],
+          [:val, p(:key?, :age)],
+          [:key, [:age, p(:int?)]],
         ]
       ]
     ]
@@ -104,11 +106,11 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:age]]]],
+          [:val, p(:key?, :age)],
           [
             :or, [
-              [:key, [:age, [:predicate, [:none?, []]]]],
-              [:key, [:age, [:predicate, [:int?, []]]]],
+              [:key, [:age, p(:none?)]],
+              [:key, [:age, p(:int?)]],
             ]
           ]
         ]
@@ -126,8 +128,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:lat]]]],
-          [:key, [:lat, [:predicate, [:float?, []]]]],
+          [:val, p(:key?, :lat)],
+          [:key, [:lat, p(:float?)]],
         ]
       ]
     ]
@@ -142,8 +144,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:lat]]]],
-          [:key, [:lat, [:predicate, [:decimal?, []]]]],
+          [:val, p(:key?, :lat)],
+          [:key, [:lat, p(:decimal?, [])]],
         ]
       ]
     ]
@@ -158,8 +160,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:date?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:date?, [])]],
         ]
       ]
     ]
@@ -174,8 +176,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:date_time?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:date_time?, [])]],
         ]
       ]
     ]
@@ -190,8 +192,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:time?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:time?, [])]],
         ]
       ]
     ]
@@ -206,8 +208,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:time?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:time?, [])]],
         ]
       ]
     ]
@@ -222,8 +224,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:admin]]]],
-          [:key, [:admin, [:predicate, [:bool?, []]]]],
+          [:val, p(:key?, :admin)],
+          [:key, [:admin, p(:bool?, [])]],
         ]
       ]
     ]
@@ -238,17 +240,17 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
     rule_ast = [
       [
         :and, [
-          [:val, [:predicate, [:key?, [:author]]]],
+          [:val, p(:key?, :author)],
           [:set, [
             [:and, [
-              [:val, [:predicate, [:key?, [:books]]]],
+              [:val, p(:key?, :books)],
               [
                 :each, [
                   :set, [
                     [
                       :and, [
-                        [:val, [:predicate, [:key?, [:published]]]],
-                        [:key, [:published, [:predicate, [:bool?, []]]]]
+                        [:val, p(:key?, :published)],
+                        [:key, [:published, p(:bool?, [])]]
                       ]
                     ]
                   ]
@@ -275,10 +277,10 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
     rule_ast = [
       [
         :and, [
-          [:val, [:predicate, [:key?, [:ids]]]],
+          [:val, p(:key?, :ids)],
           [:and, [
-            [:key, [:ids, [:predicate, [:array?, []]]]],
-            [:each, [:val, [:predicate, [:int?, []]]]]
+            [:key, [:ids, p(:array?, [])]],
+            [:each, [:val, p(:int?, [])]]
           ]]
         ]
       ]
@@ -295,16 +297,16 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
     rule_ast = [
       [
         :and, [
-          [:val, [:predicate, [:key?, [:address]]]],
+          [:val, p(:key?, :address)],
           [
             :and, [
-              [:key, [:address, [:predicate, [:hash?, []]]]],
+              [:key, [:address, p(:hash?, [])]],
               [
                 :set, [
                   [
                     :and, [
-                      [:val, [:predicate, [:key?, [:street]]]],
-                      [:key, [:street, [:predicate, [:filled?, []]]]]
+                      [:val, p(:key?, :street)],
+                      [:key, [:street, p(:filled?, [])]]
                     ]
                   ]
                 ]