dry-logic 0.1.4 → 0.2.0

data/spec/unit/rule/check_spec.rb

@@ -1,56 +1,43 @@
 RSpec.describe Rule::Check do
   include_context 'predicates'
 
-  let(:other) do
-    Rule::Value.new(:name, none?).or(Rule::Value.new(:name, filled?))
-  end
-
   describe '#call' do
-    subject(:rule) do
-      Rule::Check::Unary.new(:name, other.(input).curry(predicate), [:name])
-    end
+    context 'with 1-level nesting' do
+      subject(:rule) do
+        Rule::Check.new(eql?.curry(1), name: :compare, keys: [:num])
+      end
 
-    context 'when the given predicate passed' do
-      let(:input) { 'Jane' }
-      let(:predicate) { :filled? }
+      it 'applies predicate to args extracted from the input' do
+        expect(rule.(num: 1)).to be_success
+        expect(rule.(num: 2)).to be_failure
 
-      it 'returns a success' do
-        expect(rule.('Jane')).to be_success
+        expect(rule.(num: 1).to_ast).to eql(
+          [:input, [:compare, [
+            :result, [1, [:check, [:compare, [:predicate, [:eql?, [1]]]]]]]]
+          ]
+        )
       end
     end
 
-    context 'when the given predicate did not pass' do
-      let(:input) { nil }
-      let(:predicate) { :filled? }
-
-      it 'returns a failure' do
-        expect(rule.(nil)).to be_failure
+    context 'with 2-levels nesting' do
+      subject(:rule) do
+        Rule::Check.new(eql?, name: :compare, keys: [[:nums, :left], [:nums, :right]])
       end
-    end
-  end
 
-  describe '#call with a nested result' do
-    subject(:rule) do
-      Rule::Check::Binary.new(:address, result, [:user, { user: :address }])
-    end
+      it 'applies predicate to args extracted from the input' do
+        expect(rule.(nums: { left: 1, right: 1 })).to be_success
+        expect(rule.(nums: { left: 1, right: 2 })).to be_failure
+      end
 
-    let(:other) { Rule::Value.new(:user, hash?) }
-    let(:result) { other.(input).curry(:hash?) }
-    let(:input) { { address: 'Earth' } }
+      it 'curries args properly' do
+        result = rule.(nums: { left: 1, right: 2 })
 
-    it 'evaluates the input' do
-      expect(rule.(user: result).to_ary).to eql([
-        :input, [
-          :address, { address: 'Earth' },
-          [
-            [:check, [
-              :address, [
-                :input, [:user, { address: 'Earth' }, [
-                  [:val, [:user, [:predicate, [:hash?, []]]]]]]]
-            ]]
+        expect(result.to_ast).to eql([
+          :input, [:compare, [
+            :result, [1, [:check, [:compare, [:predicate, [:eql?, [2]]]]]]]
           ]
-        ]
-      ])
+        ])
+      end
     end
   end
 end

data/spec/unit/rule/conjunction_spec.rb

@@ -3,8 +3,8 @@ RSpec.describe Rule::Composite::Conjunction do
 
   subject(:rule) { Rule::Composite::Conjunction.new(left, right) }
 
-  let(:left) { Rule::Value.new(:age, int?) }
-  let(:right) { Rule::Value.new(:age, gt?.curry(18)) }
+  let(:left) { Rule::Value.new(int?) }
+  let(:right) { Rule::Value.new(gt?.curry(18)) }
 
   describe '#call' do
     it 'calls left and right' do
@@ -13,7 +13,7 @@ RSpec.describe Rule::Composite::Conjunction do
   end
 
   describe '#and' do
-    let(:other) { Rule::Value.new(:age, lt?.curry(30)) }
+    let(:other) { Rule::Value.new(lt?.curry(30)) }
 
     it 'creates conjunction with the other' do
       expect(rule.and(other).(31)).to be_failure
@@ -21,7 +21,7 @@ RSpec.describe Rule::Composite::Conjunction do
   end
 
   describe '#or' do
-    let(:other) { Rule::Value.new(:age, lt?.curry(14)) }
+    let(:other) { Rule::Value.new(lt?.curry(14)) }
 
     it 'creates disjunction with the other' do
       expect(rule.or(other).(13)).to be_success

data/spec/unit/rule/disjunction_spec.rb

@@ -3,11 +3,11 @@ RSpec.describe Rule::Composite::Disjunction do
 
   subject(:rule) { Rule::Composite::Disjunction.new(left, right) }
 
-  let(:left) { Rule::Value.new(:age, none?) }
-  let(:right) { Rule::Value.new(:age, gt?.curry(18)) }
+  let(:left) { Rule::Value.new(none?) }
+  let(:right) { Rule::Value.new(gt?.curry(18)) }
 
   let(:other) do
-    Rule::Value.new(:age, int?) & Rule::Value.new(:age, lt?.curry(14))
+    Rule::Value.new(int?) & Rule::Value.new(lt?.curry(14))
   end
 
   describe '#call' do

data/spec/unit/rule/each_spec.rb

@@ -4,10 +4,10 @@ RSpec.describe Dry::Logic::Rule::Each do
   include_context 'predicates'
 
   subject(:address_rule) do
-    Dry::Logic::Rule::Each.new(:name, is_string)
+    Dry::Logic::Rule::Each.new(is_string)
   end
 
-  let(:is_string) { Dry::Logic::Rule::Value.new(:name, str?) }
+  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
 
   describe '#call' do
     it 'applies its rules to all elements in the input' do

data/spec/unit/rule/exclusive_disjunction_spec.rb

@@ -0,0 +1,19 @@
+RSpec.describe Rule::ExclusiveDisjunction do
+  include_context 'predicates'
+
+  subject(:rule) do
+    Rule::ExclusiveDisjunction.new(left, right)
+  end
+
+  let(:left) { Rule::Key.new(true?, name: :eat_cake) }
+  let(:right) { Rule::Key.new(true?, name: :have_cake) }
+
+  describe '#call' do
+    it 'calls left and right' do
+      expect(rule.(eat_cake: true, have_cake: false)).to be_success
+      expect(rule.(eat_cake: false, have_cake: true)).to be_success
+      expect(rule.(eat_cake: false, have_cake: false)).to be_failure
+      expect(rule.(eat_cake: true, have_cake: true)).to be_failure
+    end
+  end
+end

data/spec/unit/rule/implication_spec.rb

@@ -3,8 +3,8 @@ RSpec.describe Rule::Composite::Implication do
 
   subject(:rule) { Rule::Composite::Implication.new(left, right) }
 
-  let(:left) { Rule::Value.new(:age, int?) }
-  let(:right) { Rule::Value.new(:age, gt?.curry(18)) }
+  let(:left) { Rule::Value.new(int?) }
+  let(:right) { Rule::Value.new(gt?.curry(18)) }
 
   describe '#call' do
     it 'calls left and right' do

data/spec/unit/rule/key_spec.rb

@@ -1,27 +1,121 @@
 require 'dry/logic/rule'
 
-RSpec.describe Dry::Logic::Rule::Key do
+RSpec.describe Rule::Key do
   include_context 'predicates'
 
-  subject(:rule) { Dry::Logic::Rule::Key.new(:name, key?) }
+  subject(:rule) do
+    Rule::Key.new(predicate, name: :user)
+  end
+
+  let(:predicate) do
+    key?.curry(:name)
+  end
 
   describe '#call' do
-    it 'applies predicate to the value' do
-      expect(rule.(name: 'Jane')).to be_success
-      expect(rule.({})).to be_failure
+    context 'with a plain predicate' do
+      it 'applies predicate to the value' do
+        expect(rule.(user: { name: 'Jane' })).to be_success
+        expect(rule.(user: {})).to be_failure
+      end
+
+      context 'with a custom predicate' do
+        let(:predicate) { -> input { double(success?: true, to_ast: [:foo]) } }
+
+        let(:result) { rule.(test: true) }
+
+        it 'delegates to_ast to response' do
+          expect(result.to_ast).to eql([:foo])
+        end
+      end
+    end
+
+    context 'with a set rule as predicate' do
+      subject(:rule) do
+        Rule::Key.new(predicate, name: :address)
+      end
+
+      let(:predicate) do
+        Rule::Set.new(
+          [Rule::Value.new(key?.curry(:city)), Rule::Value.new(key?.curry(:zipcode))]
+        )
+      end
+
+      it 'applies set rule to the value that passes' do
+        result = rule.(address: { city: 'NYC', zipcode: '123' })
+
+        expect(result).to be_success
+      end
+
+      it 'applies set rule to the value that fails' do
+        result = rule.(address: { city: 'NYC' })
+
+        expect(result).to be_failure
+
+        expect(result.to_ast).to eql([
+          :input, [
+            :address,
+              [:result, [
+                { city: "NYC" },
+                [:set, [[:result, [{ city: 'NYC' }, [:val, [:predicate, [:key?, [:zipcode]]]]]]]]
+              ]]
+            ]
+        ])
+      end
+    end
+
+    context 'with an each rule as predicate' do
+      subject(:rule) do
+        Rule::Key.new(predicate, name: :nums)
+      end
+
+      let(:predicate) do
+        Rule::Each.new(Rule::Value.new(str?))
+      end
+
+      it 'applies each rule to the value that passses' do
+        result = rule.(nums: %w(1 2 3))
+
+        expect(result).to be_success
+
+        expect(result.to_ast).to eql([
+          :input, [:nums, [:result, [%w(1 2 3), [:each, []]]]]
+        ])
+      end
+
+      it 'applies each rule to the value that fails' do
+        failure = rule.(nums: [1, '3', 3])
+
+        expect(failure).to be_failure
+
+        expect(failure.to_ast).to eql([
+          :input, [
+            :nums, [
+              :result, [
+                [1, '3', 3],
+                [:each, [
+                  [:el, [0, [:result, [1, [:val, [:predicate, [:str?, []]]]]]]],
+                  [:el, [2, [:result, [3, [:val, [:predicate, [:str?, []]]]]]]]
+                ]]
+              ]
+            ]
+          ]
+        ])
+      end
     end
   end
 
   describe '#and' do
-    let(:other) { Dry::Logic::Rule::Value.new(:name, str?) }
+    let(:other) do
+      Rule::Key.new(str?, name: [:user, :name])
+    end
 
     it 'returns conjunction rule where value is passed to the right' do
       present_and_string = rule.and(other)
 
-      expect(present_and_string.(name: 'Jane')).to be_success
+      expect(present_and_string.(user: { name: 'Jane' })).to be_success
 
-      expect(present_and_string.({})).to be_failure
-      expect(present_and_string.(name: 1)).to be_failure
+      expect(present_and_string.(user: {})).to be_failure
+      expect(present_and_string.(user: { name: 1 })).to be_failure
     end
   end
 end

data/spec/unit/rule/set_spec.rb

@@ -4,11 +4,11 @@ RSpec.describe Dry::Logic::Rule::Set do
   include_context 'predicates'
 
   subject(:rule) do
-    Dry::Logic::Rule::Set.new(:address, [is_string, min_size.curry(6)])
+    Dry::Logic::Rule::Set.new([is_string, min_size.curry(6)])
   end
 
-  let(:is_string) { Dry::Logic::Rule::Value.new(:name, str?) }
-  let(:min_size) { Dry::Logic::Rule::Value.new(:name, min_size?) }
+  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
+  let(:min_size) { Dry::Logic::Rule::Value.new(min_size?) }
 
   describe '#call' do
     it 'applies its rules to the input' do
@@ -17,14 +17,12 @@ RSpec.describe Dry::Logic::Rule::Set do
     end
   end
 
-  describe '#to_ary' do
+  describe '#to_ast' do
     it 'returns an array representation' do
-      expect(rule).to match_array([
+      expect(rule.to_ast).to eql([
         :set, [
-          :address, [
-            [:val, [:name, [:predicate, [:str?, []]]]],
-            [:val, [:name, [:predicate, [:min_size?, [6]]]]]
-          ]
+          [:val, [:predicate, [:str?, []]]],
+          [:val, [:predicate, [:min_size?, [6]]]]
         ]
       ])
     end

data/spec/unit/rule/value_spec.rb

@@ -3,17 +3,43 @@ require 'dry/logic/rule'
 RSpec.describe Dry::Logic::Rule::Value do
   include_context 'predicates'
 
-  let(:is_nil) { Dry::Logic::Rule::Value.new(:name, none?) }
+  let(:is_nil) { Dry::Logic::Rule::Value.new(none?) }
 
-  let(:is_string) { Dry::Logic::Rule::Value.new(:name, str?) }
+  let(:is_string) { Dry::Logic::Rule::Value.new(str?) }
 
-  let(:min_size) { Dry::Logic::Rule::Value.new(:name, min_size?) }
+  let(:min_size) { Dry::Logic::Rule::Value.new(min_size?) }
 
   describe '#call' do
     it 'returns result of a predicate' do
       expect(is_string.(1)).to be_failure
       expect(is_string.('1')).to be_success
     end
+
+    context 'with a custom predicate' do
+      subject(:rule) { Dry::Logic::Rule::Value.new(predicate) }
+
+      let(:response) { double(success?: true) }
+      let(:predicate) { -> input { Result.new(response, double, input) } }
+
+      let(:result) { rule.(test: true) }
+
+      it 'calls its predicate returning custom result' do
+        expect(result).to be_success
+      end
+
+      it 'exposes access to nested result' do
+        expect(response).to receive(:[]).with(:foo).and_return(:bar)
+        expect(result[:foo]).to be(:bar)
+      end
+
+      it 'returns nil from [] when response does not respond to it' do
+        expect(result[:foo]).to be(nil)
+      end
+
+      it 'has no name by default' do
+        expect(result.name).to be(nil)
+      end
+    end
   end
 
   describe '#and' do

data/spec/unit/rule_compiler_spec.rb

@@ -8,58 +8,44 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
       attr?: predicate,
       filled?: predicate,
       gt?: predicate,
-      email: val_rule.('email').curry(:filled?),
-      left: res_left_rule,
-      right: double(input: 312) }
+      one: predicate }
   }
 
   let(:predicate) { double(:predicate).as_null_object }
 
-  let(:key_rule) { Rule::Key.new(:email, predicate) }
-  let(:not_key_rule) { Rule::Key.new(:email, predicate).negation }
-  let(:attr_rule) { Rule::Attr.new(:email, predicate) }
-  let(:val_rule) { Rule::Value.new(:email, predicate) }
-  let(:check_rule) { Rule::Check::Unary.new(:email, predicates[:email], [:email]) }
-  let(:res_rule) { Rule::Result.new(:email, predicates[:email]) }
-  let(:res_left_rule) { Rule::Result.new(:left, predicate) }
+  let(:val_rule) { Rule::Value.new(predicate) }
+  let(:key_rule) { Rule::Key.new(predicate, name: :email) }
+  let(:attr_rule) { Rule::Attr.new(predicate, name: :email) }
+  let(:not_key_rule) { Rule::Key.new(predicate, name: :email).negation }
+  let(:check_rule) { Rule::Check.new(predicate, name: :email, keys: [:email]) }
   let(:and_rule) { key_rule & val_rule }
   let(:or_rule) { key_rule | val_rule }
   let(:xor_rule) { key_rule ^ val_rule }
-  let(:set_rule) { Rule::Set.new(:email, [val_rule]) }
-  let(:each_rule) { Rule::Each.new(:email, val_rule) }
+  let(:set_rule) { Rule::Set.new([val_rule]) }
+  let(:each_rule) { Rule::Each.new(val_rule) }
 
   it 'compiles key rules' do
-    ast = [[:key, [:email, [:predicate, [:key?, predicate]]]]]
+    ast = [[:key, [:email, [:predicate, [:filled?, []]]]]]
 
     rules = compiler.(ast)
 
     expect(rules).to eql([key_rule])
   end
 
-  it 'compiles check rules' do
-    ast = [[:check, [:email, [:predicate, [:email, [:filled?]]]]]]
-
-    rules = compiler.(ast)
-
-    expect(rules).to eql([check_rule])
-  end
-
-  it 'compiles result rules' do
-    ast = [[:res, [:email, [:predicate, [:email, [:filled?]]]]]]
+  it 'compiles attr rules' do
+    ast = [[:attr, [:email, [:predicate, [:filled?, []]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([res_rule])
+    expect(rules).to eql([attr_rule])
   end
 
-  it 'compiles result rules with res args' do
-    ast = [[:res, [:left, [:predicate, [:gt?, [:args, [[:res_arg, :right]]]]]]]]
-
-    expect(predicate).to receive(:curry).with(312)
+  it 'compiles check rules' do
+    ast = [[:check, [:email, [:predicate, [:filled?, []]]]]]
 
     rules = compiler.(ast)
 
-    expect(rules).to eql([res_left_rule])
+    expect(rules).to eql([check_rule])
   end
 
   it 'compiles attr rules' do
@@ -71,7 +57,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles negated rules' do
-    ast = [[:not, [:key, [:email, [:predicate, [:key?, predicate]]]]]]
+    ast = [[:not, [:key, [:email, [:predicate, [:filled?, []]]]]]]
 
     rules = compiler.(ast)
 
@@ -83,7 +69,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
       [
         :and, [
           [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
+          [:val, [:predicate, [:filled?, []]]]
         ]
       ]
     ]
@@ -98,7 +84,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
       [
         :or, [
           [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
+          [:val, [:predicate, [:filled?, []]]]
         ]
       ]
     ]
@@ -113,7 +99,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
       [
         :xor, [
           [:key, [:email, [:predicate, [:key?, []]]]],
-          [:val, [:email, [:predicate, [:filled?, []]]]]
+          [:val, [:predicate, [:filled?, []]]]
         ]
       ]
     ]
@@ -124,15 +110,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles set rules' do
-    ast = [
-      [
-        :set, [
-          :email, [
-            [:val, [:email, [:predicate, [:filled?, []]]]]
-          ]
-        ]
-      ]
-    ]
+    ast = [[:set, [[:val, [:predicate, [:filled?, []]]]]]]
 
     rules = compiler.(ast)
 
@@ -140,13 +118,7 @@ RSpec.describe Dry::Logic::RuleCompiler, '#call' do
   end
 
   it 'compiles each rules' do
-    ast = [
-      [
-        :each, [
-          :email, [:val, [:email, [:predicate, [:filled?, []]]]]
-        ]
-      ]
-    ]
+    ast = [[:each, [:val, [:predicate, [:filled?, []]]]]]
 
     rules = compiler.(ast)