dry-validation 0.6.0 → 0.7.0

data/spec/shared/rule_compiler.rb

@@ -0,0 +1,8 @@
+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

@@ -10,6 +10,7 @@ if RUBY_ENGINE == "rbx"
 end
 
 require 'dry-validation'
+require 'ostruct'
 
 SPEC_ROOT = Pathname(__dir__)
 
@@ -18,6 +19,18 @@ Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
 
 include Dry::Validation
 
+class Schema::DSL < BasicObject
+  def inspect
+    to_ast.inspect
+  end
+end
+
+class Schema::Rule < BasicObject
+  def inspect
+    to_ast.inspect
+  end
+end
+
 RSpec.configure do |config|
   config.disable_monkey_patching!
 

data/spec/unit/hint_compiler_spec.rb

@@ -7,14 +7,14 @@ RSpec.describe HintCompiler, '#call' do
     [
       [
         :and, [
-          [:key, [:age, [:predicate, [:key?, []]]]],
+          [:val, [:predicate, [:key?, [:age]]]],
           [
             :or, [
-              [:val, [:age, [:predicate, [:none?, []]]]],
+              [:key, [:age, [:predicate, [:none?, []]]]],
               [
                 :and, [
-                  [:val, [:age, [:predicate, [:int?, []]]]],
-                  [:val, [:age, [:predicate, [:gt?, [18]]]]]
+                  [:key, [:age, [:predicate, [:int?, []]]]],
+                  [:key, [:age, [:predicate, [:gt?, [18]]]]]
                 ]
               ]
             ]
@@ -23,14 +23,14 @@ RSpec.describe HintCompiler, '#call' do
       ],
       [
         :and, [
-          [:attr, [:height, [:predicate, [:attr?, []]]]],
+          [:val, [:predicate, [:attr?, [:height]]]],
           [
             :or, [
-              [:val, [:height, [:predicate, [:none?, []]]]],
+              [:attr, [:height, [:predicate, [:none?, []]]]],
               [
                 :and, [
-                  [:val, [:height, [:predicate, [:int?, []]]]],
-                  [:val, [:height, [:predicate, [:gt?, [180]]]]]
+                  [:attr, [:height, [:predicate, [:int?, []]]]],
+                  [:attr, [:height, [:predicate, [:gt?, [180]]]]]
                 ]
               ]
             ]
@@ -42,8 +42,8 @@ RSpec.describe HintCompiler, '#call' do
 
   it 'returns hint messages for given rules' do
     expect(compiler.call).to eql(
-      age: ['age must be an integer', 'age must be greater than 18'],
-      height: ['height must be an integer', 'height must be greater than 180'],
+      age: ['must be greater than 18'],
+      height: ['must be greater than 180'],
     )
   end
 end

data/spec/unit/{input_type_compiler_spec.rb → input_processor_compiler/form_spec.rb}

@@ -1,31 +1,29 @@
-require 'dry/validation/input_type_compiler'
-
-RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
-  subject(:compiler) { Dry::Validation::InputTypeCompiler.new }
+RSpec.describe Dry::Validation::InputProcessorCompiler::Form, '#call' do
+  subject(:compiler) { Dry::Validation::InputProcessorCompiler::Form.new }
 
   let(:rule_ast) do
     [
       [
         :and, [
-          [:key, [:email, [:predicate, [:key?, [:email]]]]],
+          [:val, [:predicate, [:key?, [:email]]]],
           [
             :and, [
-              [:val, [:email, [:predicate, [:str?, []]]]],
-              [:val, [:email, [:predicate, [:filled?, []]]]]
+              [:key, [:email, [:predicate, [:str?, []]]]],
+              [:key, [:email, [:predicate, [:filled?, []]]]]
             ]
           ]
         ]
       ],
       [
         :and, [
-          [:key, [:age, [:predicate, [:key?, [:age]]]]],
+          [:val, [:predicate, [:key?, [:age]]]],
           [
             :or, [
-              [:val, [:age, [:predicate, [:none?, []]]]],
+              [:key, [:age, [:predicate, [:none?, []]]]],
               [
                 :and, [
-                  [:val, [:age, [:predicate, [:int?, []]]]],
-                  [:val, [:age, [:predicate, [:filled?, []]]]]
+                  [:key, [:age, [:predicate, [:int?, []]]]],
+                  [:key, [:age, [:predicate, [:filled?, []]]]]
                 ]
               ]
             ]
@@ -34,32 +32,64 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       ],
       [
         :and, [
-          [:key, [:address, [:predicate, [:key?, [:address]]]]],
-          [:val, [:address, [:predicate, [:str?, []]]]]
+          [:val, [:predicate, [:key?, [:address]]]],
+          [:key, [:address, [:predicate, [:str?, []]]]]
         ]
       ]
-    ].map(&:to_ary)
+    ]
   end
 
-  let(:params) do
+  let(:output) do
     { 'email' => 'jane@doe.org', 'age' => '20', 'address' => 'City, Street 1/2' }
   end
 
   it 'builds an input dry-data type' do
     input_type = compiler.(rule_ast)
 
-    result = input_type[params]
+    result = input_type[output]
 
     expect(result).to eql(email: 'jane@doe.org', age: 20, address: 'City, Street 1/2')
   end
 
+  it 'supports arbitrary types via type?(const) => "form.const"' do
+    rule_ast = [
+      [
+        :and,
+        [
+          [:val, [:predicate, [:key?, [:age]]]],
+          [:key, [:age, [:predicate, [:type?, [Fixnum]]]]]
+        ]
+      ]
+    ]
+
+    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, [:predicate, [:key?, [:admin]]]],
+          [:key, [:admin, [:predicate, [:type?, ['Form::Bool']]]]]
+        ]
+      ]
+    ]
+
+    input_type = compiler.(rule_ast)
+
+    expect(input_type['admin' => '0']).to eql(admin: false)
+  end
+
   it 'supports int? => "form.int"' do
     rule_ast = [
       [
         :and,
         [
-          [:key, [:age, [:predicate, [:key?, [:age]]]]],
-          [:val, [:age, [:predicate, [:int?, []]]]],
+          [:val, [:predicate, [:key?, [:age]]]],
+          [:key, [:age, [:predicate, [:int?, []]]]],
         ]
       ]
     ]
@@ -74,11 +104,11 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:age, [:predicate, [:key?, [:age]]]]],
+          [:val, [:predicate, [:key?, [:age]]]],
           [
             :or, [
-              [:val, [:age, [:predicate, [:none?, []]]]],
-              [:val, [:age, [:predicate, [:int?, []]]]],
+              [:key, [:age, [:predicate, [:none?, []]]]],
+              [:key, [:age, [:predicate, [:int?, []]]]],
             ]
           ]
         ]
@@ -96,8 +126,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:lat, [:predicate, [:key?, [:lat]]]]],
-          [:val, [:lat, [:predicate, [:float?, []]]]],
+          [:val, [:predicate, [:key?, [:lat]]]],
+          [:key, [:lat, [:predicate, [:float?, []]]]],
         ]
       ]
     ]
@@ -112,8 +142,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:lat, [:predicate, [:key?, [:lat]]]]],
-          [:val, [:lat, [:predicate, [:decimal?, []]]]],
+          [:val, [:predicate, [:key?, [:lat]]]],
+          [:key, [:lat, [:predicate, [:decimal?, []]]]],
         ]
       ]
     ]
@@ -128,8 +158,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
-          [:val, [:bday, [:predicate, [:date?, []]]]],
+          [:val, [:predicate, [:key?, [:bday]]]],
+          [:key, [:bday, [:predicate, [:date?, []]]]],
         ]
       ]
     ]
@@ -144,8 +174,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
-          [:val, [:bday, [:predicate, [:date_time?, []]]]],
+          [:val, [:predicate, [:key?, [:bday]]]],
+          [:key, [:bday, [:predicate, [:date_time?, []]]]],
         ]
       ]
     ]
@@ -160,8 +190,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
-          [:val, [:bday, [:predicate, [:time?, []]]]],
+          [:val, [:predicate, [:key?, [:bday]]]],
+          [:key, [:bday, [:predicate, [:time?, []]]]],
         ]
       ]
     ]
@@ -176,8 +206,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:bday, [:predicate, [:key?, [:bday]]]]],
-          [:val, [:bday, [:predicate, [:time?, []]]]],
+          [:val, [:predicate, [:key?, [:bday]]]],
+          [:key, [:bday, [:predicate, [:time?, []]]]],
         ]
       ]
     ]
@@ -192,8 +222,8 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
       [
         :and,
         [
-          [:key, [:admin, [:predicate, [:key?, [:admin]]]]],
-          [:val, [:admin, [:predicate, [:bool?, []]]]],
+          [:val, [:predicate, [:key?, [:admin]]]],
+          [:key, [:admin, [:predicate, [:bool?, []]]]],
         ]
       ]
     ]
@@ -208,35 +238,24 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
     rule_ast = [
       [
         :and, [
-          [:key, [:author, [:predicate, [:key?, []]]]],
-          [
-            :set, [
-              :author, [
-                [
-                  :and, [
-                    [:key, [:books, [:predicate, [:key?, []]]]],
+          [:val, [:predicate, [:key?, [:author]]]],
+          [:set, [
+            [:and, [
+              [:val, [:predicate, [:key?, [:books]]]],
+              [
+                :each, [
+                  :set, [
                     [
-                      :each, [
-                        :books,
-                        [
-                          :set, [
-                            :books, [
-                              [
-                                :and, [
-                                  [:key, [:published, [:predicate, [:key?, []]]]],
-                                  [:val, [:published, [:predicate, [:bool?, []]]]]
-                                ]
-                              ]
-                            ]
-                          ]
-                        ]
+                      :and, [
+                        [:val, [:predicate, [:key?, [:published]]]],
+                        [:key, [:published, [:predicate, [:bool?, []]]]]
                       ]
                     ]
                   ]
                 ]
               ]
-            ]
-          ]
+            ]]
+          ]]
         ]
       ]
     ]
@@ -256,13 +275,11 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
     rule_ast = [
       [
         :and, [
-          [:key, [:ids, [:predicate, [:key?, []]]]],
-          [
-            :and, [
-              [:val, [:ids, [:predicate, [:array?, []]]]],
-              [:each, [:ids, [:val, [:ids, [:predicate, [:int?, []]]]]]]
-            ]
-          ]
+          [:val, [:predicate, [:key?, [:ids]]]],
+          [:and, [
+            [:key, [:ids, [:predicate, [:array?, []]]]],
+            [:each, [:val, [:predicate, [:int?, []]]]]
+          ]]
         ]
       ]
     ]
@@ -278,18 +295,16 @@ RSpec.describe Dry::Validation::InputTypeCompiler, '#call' do
     rule_ast = [
       [
         :and, [
-          [:key, [:address, [:predicate, [:key?, []]]]],
+          [:val, [:predicate, [:key?, [:address]]]],
           [
             :and, [
-              [:val, [:address, [:predicate, [:hash?, []]]]],
+              [:key, [:address, [:predicate, [:hash?, []]]]],
               [
                 :set, [
-                  :address, [
-                    [
-                      :and, [
-                        [:key, [:street, [:predicate, [:key?, []]]]],
-                        [:val, [:street, [:predicate, [:filled?, []]]]]
-                      ]
+                  [
+                    :and, [
+                      [:val, [:predicate, [:key?, [:street]]]],
+                      [:key, [:street, [:predicate, [:filled?, []]]]]
                     ]
                   ]
                 ]

data/spec/unit/schema/key_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Schema::Key do
+  describe '#key?' do
+    subject(:user) { Schema::Key[:user] }
+
+    it 'returns a key rule' do
+      rule = user.key?(:address)
+
+      expect(rule.to_ast).to eql([:key, [:user, [:predicate, [:key?, [:address]]]]])
+    end
+
+    it 'returns a key rule & disjunction rule created within the block' do
+      user.hash? do
+        key(: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?, []]]]]]
+                ]]
+            ]]]]]
+          ]
+        ]]
+      ])
+    end
+  end
+end

data/spec/unit/schema/rule_spec.rb

@@ -2,30 +2,31 @@ RSpec.describe Schema::Rule do
   let(:filled) { [:val, [:email, [:predicate, [:filled?, []]]]] }
   let(:format) { [:val, [:email, [:predicate, [:format?, [/regex/]]]]] }
 
-  let(:left) { Schema::Rule.new(:email, filled) }
-  let(:right) { Schema::Rule.new(:email, format) }
+  let(:left) { Schema::Rule.new(filled, name: :email, target: target) }
+  let(:right) { Schema::Rule.new(format, name: :email, target: target) }
+  let(:target) { double(:target, id: :user) }
 
   describe '#and' do
     it 'returns a conjunction' do
-      expect(left.and(right).to_ary).to match_array([:and, [filled, format]])
+      expect(left.and(right).to_ast).to match_array([:and, [filled, format]])
     end
   end
 
   describe '#or' do
     it 'returns a disjunction' do
-      expect(left.or(right).to_ary).to match_array([:or, [filled, format]])
+      expect(left.or(right).to_ast).to match_array([:or, [filled, format]])
     end
   end
 
   describe '#xor' do
     it 'returns an exclusive disjunction' do
-      expect(left.xor(right).to_ary).to match_array([:xor, [filled, format]])
+      expect(left.xor(right).to_ast).to match_array([:xor, [filled, format]])
     end
   end
 
   describe '#then' do
     it 'returns an implication' do
-      expect(left.then(right).to_ary).to match_array([:implication, [filled, format]])
+      expect(left.then(right).to_ast).to match_array([:implication, [filled, format]])
     end
   end
 end

data/spec/unit/schema/value_spec.rb

@@ -1,82 +1,215 @@
 RSpec.describe Schema::Value do
+  include_context 'rule compiler'
+
+  describe '#key' do
+    subject(:value) { Schema::Value.new }
+
+    let(:expected_ast) do
+      [:and, [
+        [:val, [:predicate, [:key?, [:address]]]],
+        [:key, [:address, [:predicate, [:filled?, []]]]]
+      ]]
+    end
+
+    it 'creates a rule for a specified key using a block' do
+      rule = value.key(: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
+
+      expect(rule.to_ast).to eql(expected_ast)
+    end
+  end
+
   describe '#each' do
-    subject(:value) { Schema::Value.new(:payments) }
+    subject(:value) { Schema::Value.new }
 
     it 'creates an each rule with another rule returned from the block' do
-      rule = value.each do
-        value.key?(:method)
-      end
+      rule = value.each { key?(:method) }
 
-      expect(rule.to_ary).to match_array(
-        [:each, [
-          :payments, [:val, [:payments, [:predicate, [:key?, [:method]]]]]]
-        ]
+      expect(rule.to_ast).to eql(
+        [:and, [
+          [:val, [:predicate, [:array?, []]]],
+          [:each, [:val, [:predicate, [:key?, [:method]]]]]
+        ]]
       )
     end
 
     it 'creates an each rule with other rules returned from the block' do
       rule = value.each do
-        value.key(:method) { |method| method.str? }
-        value.key(:amount) { |amount| amount.float? }
+        key(:method) { str? }
+        key(:amount) { float? }
       end
 
-      expect(rule.to_ary).to match_array(
-        [:each, [
-          :payments, [
-            :set, [
-              :payments, [
-                [:and, [
-                  [:key, [:method, [:predicate, [:key?, []]]]],
-                  [:val, [:method, [:predicate, [:str?, []]]]]
-                ]],
-                [:and, [
-                  [:key, [:amount, [:predicate, [:key?, []]]]],
-                  [:val, [:amount, [:predicate, [:float?, []]]]]
-                ]],
-              ]
-            ]
-          ]
+      expect(rule.to_ast).to eql(
+        [:and, [
+          [:val, [:predicate, [:array?, []]]],
+          [:each,
+            [:set, [
+              [:and, [
+                [:val, [:predicate, [:key?, [:method]]]],
+                [:key, [:method, [:predicate, [:str?, []]]]]
+              ]],
+              [:and, [
+                [:val, [:predicate, [:key?, [:amount]]]],
+                [:key, [:amount, [:predicate, [:float?, []]]]]
+              ]]
+            ]]]
         ]]
       )
     end
   end
 
-  describe '#rule' do
-    subject(:pills) { Schema::Value.new(:pills) }
-
-    it 'appends new check rule' do
-      pills.key(:red, &:filled?)
-      pills.key(:blue, &:filled?)
-
-      pills.rule(:destiny) { pills.rule(:red) | pills.rule(:blue) }
-
-      expect(pills.checks.map(&:to_ary)).to match_array([
-        [
-          :check, [
-            :destiny, [
-              :or, [
-                [:check, [:red, [:predicate, [:red, []]]]],
-                [:check, [:blue, [:predicate, [:blue, []]]]]
-              ]
-            ]
-          ]
+  describe '#hash? with block' do
+    subject(:user) { Schema::Value.new }
+
+    it 'builds hash? & rule created within the block' do
+      rule = user.hash? { key(:email).required }
+
+      expect(rule.to_ast).to eql([
+        :and, [
+          [:val, [:predicate, [:hash?, []]]],
+          [:and, [
+            [:val, [:predicate, [:key?, [:email]]]],
+            [:key, [:email, [:predicate, [:filled?, []]]]]
+          ]]
         ]
       ])
     end
+
+    it 'builds hash? & rule created within the block with deep nesting' do
+      rule = user.hash? do
+        key(:address) do
+          hash? do
+            key(:city).required
+            key(:zipcode).required
+          end
+        end
+      end
+
+      expect(rule.to_ast).to eql(
+        [:and, [
+          [:val, [:predicate, [:hash?, []]]],
+          [:and, [
+            [:val, [:predicate, [:key?, [:address]]]],
+            [:and, [
+              [:val, [:predicate, [:hash?, []]]],
+              [:key, [
+                :address, [:set, [
+                  [:and, [
+                    [:val, [:predicate, [:key?, [:city]]]],
+                    [:key, [:city, [:predicate, [:filled?, []]]]]]],
+                  [:and, [
+                    [:val, [:predicate, [:key?, [:zipcode]]]],
+                    [:key, [:zipcode, [:predicate, [:filled?, []]]]]]]
+                ]]
+              ]]
+            ]]
+          ]]
+        ]]
+      )
+    end
   end
 
   describe '#not' do
-    subject(:user) { Schema::Value.new(:user) }
+    subject(:user) { Schema::Value.new }
 
     it 'builds a negated rule' do
-      not_email = user.key(:email, &:str?).first.not
-
-      expect(not_email.to_ary).to eql([
-        :not, [
-          :and, [
-            [:key, [:email, [:predicate, [:key?, []]]]],
-            [:val, [:email, [:predicate, [:str?, []]]]]
-          ]
+      not_email = user.key(:email) { str?.not }
+
+      expect(not_email.to_ast).to eql([
+        :and, [
+          [:val, [:predicate, [:key?, [:email]]]],
+          [:not, [:key, [:email, [:predicate, [:str?, []]]]]]
         ]
       ])
     end