dry-validation 0.7.4 → 0.8.0

data/spec/unit/input_processor_compiler/json_spec.rb

@@ -1,13 +1,15 @@
 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, [:predicate, [:key?, [:age]]]],
-          [:key, [:age, [:predicate, [:type?, [Fixnum]]]]]
+          [:val, p(:key?, :age)],
+          [:key, [:age, p(:type?, Fixnum)]]
         ]
       ]
     ]
@@ -22,8 +24,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:admin]]]],
-          [:key, [:admin, [:predicate, [:type?, ['Bool']]]]]
+          [:val, p(:key?, :admin)],
+          [:key, [:admin, p(:type?, 'Bool')]]
         ]
       ]
     ]
@@ -38,11 +40,11 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' 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?, [])]]
             ]
           ]
         ]
@@ -59,8 +61,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:age]]]],
-          [:key, [:age, [:predicate, [:int?, []]]]],
+          [:val, p(:key?, :age)],
+          [:key, [:age, p(:int?, [])]],
         ]
       ]
     ]
@@ -75,8 +77,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:admin]]]],
-          [:key, [:admin, [:predicate, [:bool?, []]]]],
+          [:val, p(:key?, :admin)],
+          [:key, [:admin, p(:bool?, [])]],
         ]
       ]
     ]
@@ -92,11 +94,11 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#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?, [])]],
             ]
           ]
         ]
@@ -114,8 +116,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:lat]]]],
-          [:key, [:lat, [:predicate, [:float?, []]]]],
+          [:val, p(:key?, :lat)],
+          [:key, [:lat, p(:float?, [])]],
         ]
       ]
     ]
@@ -130,8 +132,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:lat]]]],
-          [:key, [:lat, [:predicate, [:decimal?, []]]]],
+          [:val, p(:key?, :lat)],
+          [:key, [:lat, p(:decimal?, [])]],
         ]
       ]
     ]
@@ -146,8 +148,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:date?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:date?, [])]],
         ]
       ]
     ]
@@ -162,8 +164,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:date_time?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:date_time?, [])]],
         ]
       ]
     ]
@@ -178,8 +180,8 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#call' do
       [
         :and,
         [
-          [:val, [:predicate, [:key?, [:bday]]]],
-          [:key, [:bday, [:predicate, [:time?, []]]]],
+          [:val, p(:key?, :bday)],
+          [:key, [:bday, p(:time?, [])]],
         ]
       ]
     ]
@@ -193,17 +195,17 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#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?, [])]]
                       ]
                     ]
                   ]
@@ -230,10 +232,10 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#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?, [])]]
           ]]
         ]
       ]
@@ -250,16 +252,16 @@ RSpec.describe Dry::Validation::InputProcessorCompiler::JSON, '#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?, [])]]
                     ]
                   ]
                 ]

data/spec/unit/predicate_registry_spec.rb

@@ -0,0 +1,34 @@
+require 'dry/validation/predicate_registry'
+
+RSpec.describe PredicateRegistry do
+  subject!(:predicate_registry) { schema_class.registry }
+
+  let(:schema_class) { Class.new(Schema) }
+  let(:schema) { schema_class.new }
+
+  before do
+    schema_class.class_eval { def dis_ok?; true; end }
+  end
+
+  describe '.[]' do
+    it 'returns a registry which collects predicate methods' do
+      expect(predicate_registry[:dis_ok?]).to be_instance_of(Dry::Logic::Predicate)
+    end
+  end
+
+  describe '#[]' do
+    it 'gives access to built-in predicates' do
+      expect(predicate_registry[:filled?].("sutin")).to be(true)
+    end
+  end
+
+  describe '#bind' do
+    it 'binds unbound predicates and return finalized registry' do
+      registry = predicate_registry.bind(schema)
+
+      expect(registry).to be_frozen
+      expect(registry[:dis_ok?]).to be_instance_of(Dry::Logic::Predicate)
+      expect(registry[:dis_ok?].()).to be(true)
+    end
+  end
+end

data/spec/unit/schema/key_spec.rb

@@ -1,29 +1,27 @@
 RSpec.describe Schema::Key do
-  describe '#key?' do
-    subject(:user) { Schema::Key[:user] }
+  include_context 'predicate helper'
 
-    it 'returns a key rule' do
-      rule = user.key?(:address)
+  let(:registry) { PredicateRegistry.new(predicates) }
+
+  describe '#str?' do
+    subject(:user) { Schema::Key[:user, registry: registry] }
 
-      expect(rule.to_ast).to eql([:key, [:user, [:predicate, [:key?, [:address]]]]])
+    it 'returns a key rule' do
+      expect(user.str?.to_ast).to eql([:key, [:user, p(:str?)]])
     end
 
     it 'returns a key rule & disjunction rule created within the block' do
       user.hash? do
-        key(:email) { none? | filled? }
+        required(:email) { none? | filled? }
       end
 
       expect(user.to_ast).to eql([
         :key, [:user, [
           :and, [
-            [:val, [:predicate, [:hash?, []]]],
-            [:key, [:user, [:set, [
-              [:and, [
-                [:val, [:predicate, [:key?, [:email]]]],
-                [:or, [
-                  [:key, [:email, [:predicate, [:none?, []]]]],
-                  [:key, [:email, [:predicate, [:filled?, []]]]]]
-                ]]
+            [:val, p(:hash?)],
+            [:key, [:user, [:and, [
+              [:val, p(:key?, :email)],
+              [:or, [[:key, [:email, p(:none?)]], [:key, [:email, p(:filled?)]]]
             ]]]]]
           ]
         ]]

data/spec/unit/schema/rule_spec.rb

@@ -1,6 +1,8 @@
 RSpec.describe Schema::Rule do
-  let(:filled) { [:val, [:email, [:predicate, [:filled?, []]]]] }
-  let(:format) { [:val, [:email, [:predicate, [:format?, [/regex/]]]]] }
+  include_context 'predicate helper'
+
+  let(:filled) { [:val, [:email, p(:filled?)]] }
+  let(:format) { [:val, [:email, p(:format?, /regex/)]] }
 
   let(:left) { Schema::Rule.new(filled, name: :email, target: target) }
   let(:right) { Schema::Rule.new(format, name: :email, target: target) }

data/spec/unit/schema/value_spec.rb

@@ -1,147 +1,64 @@
 RSpec.describe Schema::Value do
   include_context 'rule compiler'
+  include_context 'predicate helper'
 
-  describe '#key' do
-    subject(:value) { Schema::Value.new }
+  let(:registry) { PredicateRegistry.new(predicates) }
+
+  describe '#required' do
+    subject(:value) { Schema::Value.new(registry: registry) }
 
     let(:expected_ast) do
       [:and, [
-        [:val, [:predicate, [:key?, [:address]]]],
-        [:key, [:address, [:predicate, [:filled?, []]]]]
+        [:val, p(:key?, :address)],
+        [:key, [:address, p(:filled?)]]
       ]]
     end
 
     it 'creates a rule for a specified key using a block' do
-      rule = value.key(:address, &:filled?)
+      rule = value.required(:address, &:filled?)
 
       expect(rule.to_ast).to eql(expected_ast)
     end
 
     it 'creates a rule for a specified key using a macro' do
-      rule = value.key(:address).required
-
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-  end
-
-  describe '#key deeply nested' do
-    subject(:value) { Schema::Value.new }
-
-    let(:expected_ast) do
-      [:and, [
-        [:val, [:predicate, [:key?, [:address]]]],
-        [:key, [:address,
-          [:and, [
-            [:val, [:predicate, [:key?, [:location]]]],
-            [:key, [:location,
-              [:set, [
-                [:and, [
-                  [:val, [:predicate, [:key?, [:lat]]]],
-                  [:key, [:lat, [:predicate, [:filled?, []]]]]]
-                ],
-                [:and, [
-                  [:val, [:predicate, [:key?, [:lng]]]],
-                  [:key, [:lng, [:predicate, [:filled?, []]]]]
-                ]]
-              ]]
-            ]]]
-        ]]]
-      ]]
-    end
-
-    it 'creates a rule for specified keys using blocks' do
-      rule = value.key(:address) do
-        key(:location) do
-          key(:lat) { filled? }
-          key(:lng) { filled? }
-        end
-      end
-
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-
-    it 'creates a rule for specified keys using macros' do
-      rule = value.key(:address) do
-        key(:location) do
-          key(:lat).required
-          key(:lng).required
-        end
-      end
-
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-  end
-
-  describe '#key with multiple inner-keys' do
-    subject(:value) { Schema::Value.new }
-
-    let(:expected_ast) do
-      [:and, [
-        [:val, [:predicate, [:key?, [:address]]]],
-        [:key, [:address, [:set, [
-          [:and, [
-            [:val, [:predicate, [:key?, [:city]]]],
-            [:key, [:city, [:predicate, [:filled?, []]]]]]
-          ],
-          [:and, [
-            [:val, [:predicate, [:key?, [:zipcode]]]],
-            [:key, [:zipcode, [:predicate, [:filled?, []]]]]
-          ]]
-        ]]]]
-      ]]
-    end
-
-    it 'creates a rule for specified keys using blocks' do
-      rule = value.key(:address) do
-        key(:city) { filled? }
-        key(:zipcode) { filled? }
-      end
-
-      expect(rule.to_ast).to eql(expected_ast)
-    end
-
-    it 'creates a rule for specified keys using macros' do
-      rule = value.key(:address) do
-        key(:city).required
-        key(:zipcode).required
-      end
+      rule = value.required(:address).filled
 
       expect(rule.to_ast).to eql(expected_ast)
     end
   end
 
   describe '#each' do
-    subject(:value) { Schema::Value.new }
+    subject(:value) { Schema::Value.new(registry: registry) }
 
     it 'creates an each rule with another rule returned from the block' do
       rule = value.each { key?(:method) }
 
       expect(rule.to_ast).to eql(
         [:and, [
-          [:val, [:predicate, [:array?, []]]],
-          [:each, [:set, [[:val, [:predicate, [:key?, [:method]]]]]]]
+          [:val, p(:array?)],
+          [:each, [:val, p(:key?, :method)]]
         ]]
       )
     end
 
     it 'creates an each rule with other rules returned from the block' do
       rule = value.each do
-        key(:method) { str? }
-        key(:amount) { float? }
+        required(:method) { str? }
+        required(:amount) { float? }
       end
 
       expect(rule.to_ast).to eql(
         [:and, [
-          [:val, [:predicate, [:array?, []]]],
+          [:val, p(:array?)],
           [:each,
             [:set, [
               [:and, [
-                [:val, [:predicate, [:key?, [:method]]]],
-                [:key, [:method, [:predicate, [:str?, []]]]]
+                [:val, p(:key?, :method)],
+                [:key, [:method, p(:str?)]]
               ]],
               [:and, [
-                [:val, [:predicate, [:key?, [:amount]]]],
-                [:key, [:amount, [:predicate, [:float?, []]]]]
+                [:val, p(:key?, :amount)],
+                [:key, [:amount, p(:float?)]]
               ]]
             ]]]
         ]]
@@ -150,17 +67,17 @@ RSpec.describe Schema::Value do
   end
 
   describe '#hash? with block' do
-    subject(:user) { Schema::Value.new }
+    subject(:user) { Schema::Value.new(registry: registry) }
 
     it 'builds hash? & rule created within the block' do
-      rule = user.hash? { key(:email).required }
+      rule = user.hash? { required(:email).filled }
 
       expect(rule.to_ast).to eql([
         :and, [
-          [:val, [:predicate, [:hash?, []]]],
+          [:val, p(:hash?)],
           [:and, [
-            [:val, [:predicate, [:key?, [:email]]]],
-            [:key, [:email, [:predicate, [:filled?, []]]]]
+            [:val, p(:key?, :email)],
+            [:key, [:email, p(:filled?)]]
           ]]
         ]
       ])
@@ -168,29 +85,29 @@ RSpec.describe Schema::Value do
 
     it 'builds hash? & rule created within the block with deep nesting' do
       rule = user.hash? do
-        key(:address) do
+        required(:address) do
           hash? do
-            key(:city).required
-            key(:zipcode).required
+            required(:city).filled
+            required(:zipcode).filled
           end
         end
       end
 
       expect(rule.to_ast).to eql(
         [:and, [
-          [:val, [:predicate, [:hash?, []]]],
+          [:val, p(:hash?)],
           [:and, [
-            [:val, [:predicate, [:key?, [:address]]]],
+            [:val, p(:key?, :address)],
             [:and, [
-              [:val, [:predicate, [:hash?, []]]],
+              [:val, p(:hash?)],
               [:key, [
                 :address, [:set, [
                   [:and, [
-                    [:val, [:predicate, [:key?, [:city]]]],
-                    [:key, [:city, [:predicate, [:filled?, []]]]]]],
+                    [:val, p(:key?, :city)],
+                    [:key, [:city, p(:filled?)]]]],
                   [:and, [
-                    [:val, [:predicate, [:key?, [:zipcode]]]],
-                    [:key, [:zipcode, [:predicate, [:filled?, []]]]]]]
+                    [:val, p(:key?, :zipcode)],
+                    [:key, [:zipcode, p(:filled?)]]]]
                 ]]
               ]]
             ]]
@@ -201,15 +118,15 @@ RSpec.describe Schema::Value do
   end
 
   describe '#not' do
-    subject(:user) { Schema::Value.new }
+    subject(:user) { Schema::Value.new(registry: registry) }
 
     it 'builds a negated rule' do
-      not_email = user.key(:email) { str?.not }
+      not_email = user.required(:email) { str?.not }
 
       expect(not_email.to_ast).to eql([
         :and, [
-          [:val, [:predicate, [:key?, [:email]]]],
-          [:not, [:key, [:email, [:predicate, [:str?, []]]]]]
+          [:val, p(:key?, :email)],
+          [:not, [:key, [:email, p(:str?)]]]
         ]
       ])
     end