predicate 2.3.0 → 2.5.0

data/spec/predicate/test_bool_and.rb

@@ -38,5 +38,16 @@ class Predicate
       end
     end
 
+    context 'when using qualified names' do
+      let(:right) { Predicate.coerce(x: 2) }
+
+      it 'does not mix predicates' do
+        l = left.qualify(:p1)
+        r = right.qualify(:p2)
+        expect(l & r).not_to eql(l)
+      end
+
+    end
+
   end
 end

data/spec/predicate/test_constant_variables.rb

@@ -37,14 +37,36 @@ class Predicate
     describe "on an intersect with one value" do
       let(:p){ Predicate.intersect(:x, [2]) }
 
-      # TODO: is that correct?
       it{ expect(subject).to eql([]) }
     end
 
     describe "on an intersect with a placeholder" do
       let(:p){ Predicate.intersect(:x, Predicate.placeholder) }
 
-      # TODO: is that correct?
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an subset with one value" do
+      let(:p){ Predicate.subset(:x, [2]) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an subset with a placeholder" do
+      let(:p){ Predicate.subset(:x, Predicate.placeholder) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an superset with one value" do
+      let(:p){ Predicate.superset(:x, [2]) }
+
+      it{ expect(subject).to eql([]) }
+    end
+
+    describe "on an superset with a placeholder" do
+      let(:p){ Predicate.superset(:x, Predicate.placeholder) }
+
       it{ expect(subject).to eql([]) }
     end
 

data/spec/predicate/test_constants.rb

@@ -119,6 +119,30 @@ class Predicate
       it{ should eq({}) }
     end
 
+    context "on subset" do
+      let(:pred){ p.subset(:x, [4,8]) }
+
+      it{ should eq({}) }
+    end
+
+    context "on subset with placeholder" do
+      let(:pred){ p.subset(:x, p.placeholder) }
+
+      it{ should eq({}) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [4,8]) }
+
+      it{ should eq({}) }
+    end
+
+    context "on superset with placeholder" do
+      let(:pred){ p.superset(:x, p.placeholder) }
+
+      it{ should eq({}) }
+    end
+
     context "on or (two eqs)" do
       let(:pred){ p.eq(:x, 2) | p.eq(:y, 4) }
 

data/spec/predicate/test_evaluate.rb

@@ -40,7 +40,7 @@ class Predicate
 
     context 'on a factored predicate' do
       let(:predicate){
-        Predicate.new(Factory.lte(:x => 2))
+        Predicate.lte(:x => 2)
       }
 
       describe "on x == 2" do
@@ -80,7 +80,7 @@ class Predicate
       end
     end
 
-    context 'on an intersect predicate' do
+    context 'on an intersect predicate, with array literal' do
       let(:predicate){
         Predicate.intersect(:x, [8,9])
       }
@@ -98,6 +98,168 @@ class Predicate
       end
     end
 
+    context 'on an intersect predicate, with two variables' do
+      let(:predicate){
+        Predicate.intersect(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9,12]" do
+        let(:scope){ { :x => [9,12], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
+    context 'on an subset predicate, with an array literal' do
+      let(:predicate){
+        Predicate.subset(:x, [8,9])
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+    context 'on an subset predicate, with two variables' do
+      let(:predicate){
+        Predicate.subset(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+    end
+
+    context 'on an superset predicate, with an array literal' do
+      let(:predicate){
+        Predicate.superset(:x, [8,9])
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
+    context 'on an superset predicate, with two variables' do
+      let(:predicate){
+        Predicate.superset(:x, :y)
+      }
+
+      describe "on x == [2]" do
+        let(:scope){ { :x => [2], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == []" do
+        let(:scope){ { :x => [], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [9]" do
+        let(:scope){ { :x => [9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_falsy }
+      end
+
+      describe "on x == [8, 9]" do
+        let(:scope){ { :x => [8, 9], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+
+      describe "on x == [8, 9, 10]" do
+        let(:scope){ { :x => [8, 9, 19], :y => [8,9] } }
+
+        it{ expect(predicate.evaluate(scope)).to be_truthy }
+      end
+    end
+
     context 'on a match against a string' do
       let(:predicate){
         Predicate.match(:x, "12")
@@ -228,12 +390,52 @@ class Predicate
 
     context 'has a call alias' do
       let(:predicate){
-        Predicate.new(Factory.gte(:x => 0))
+        Predicate.gte(:x => 0)
       }
 
       let(:scope){ { x: 2 } }
 
       it{ expect(predicate.call(scope)).to be(true) }
     end
+
+    context "on a var, build with a dotted string" do
+      let(:predicate){
+        Predicate.var("x.0.y")
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to eql(2) }
+    end
+
+    context "on a var, build with a . string" do
+      let(:predicate){
+        Predicate.var(".")
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to be(scope) }
+    end
+
+    context "on a var, build with an array for terms" do
+      let(:predicate){
+        Predicate.var([:x, 0, :y])
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to eql(2) }
+    end
+
+    context "on a var, build with an empty array" do
+      let(:predicate){
+        Predicate.var([])
+      }
+
+      let(:scope){ { x: [{ y: 2 }] } }
+
+      it{ expect(predicate.call(scope)).to be(scope) }
+    end
   end
 end

data/spec/predicate/test_free_variables.rb

@@ -9,6 +9,6 @@ class Predicate
 
       it{ should eq([:x]) }
     end
-    
+
   end
 end

data/spec/predicate/test_to_hash.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "to_hash" do
+
+    let(:p){ Predicate }
+
+    subject{ predicate.to_hash }
+
+    context "tautology" do
+      let(:predicate){ Predicate.tautology }
+
+      it{ expect(subject).to eql({}) }
+    end
+
+    context "contradiction" do
+      let(:predicate){ Predicate.contradiction }
+
+      it{ expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "eq" do
+      let(:predicate){ Predicate.eq(:x, 2) }
+
+      it{ expect(subject).to eql(x: 2) }
+    end
+
+    context "in" do
+      let(:predicate){ Predicate.in(:x, [2,3]) }
+
+      it{ expect(subject).to eql(x: [2,3]) }
+    end
+
+    context "and" do
+      let(:predicate){ Predicate.eq(:x, 3) & Predicate.in(:y, [2,3]) }
+
+      it{ expect(subject).to eql(x: 3, y: [2,3]) }
+    end
+
+  end
+end

data/spec/predicate/test_to_s.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "to_s" do
+
+    let(:p){ Predicate }
+
+    subject{ predicate.to_s }
+
+    context "tautology" do
+      let(:predicate){ Predicate.tautology }
+
+      it{ expect(subject).to eql("true") }
+    end
+
+    context "contradiction" do
+      let(:predicate){ Predicate.contradiction }
+
+      it{ expect(subject).to eql("false") }
+    end
+
+    context "var" do
+      let(:predicate){ Predicate.var("x.y") }
+
+      it{ expect(subject).to eql("dig(x.y)") }
+    end
+
+    context "var when used in another predicate" do
+      let(:predicate){
+        v = Predicate.var("x.y")
+        Predicate.eq(v, 6)
+      }
+
+      it{ expect(subject).to eql("dig(x.y) == 6") }
+    end
+
+  end
+end

data/spec/predicate/test_unqualify.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "unqualify" do
+
+    let(:p){ Predicate }
+
+    subject{ predicate.unqualify }
+
+    context 'when the predicate is not qualified' do
+      let(:predicate){ p.in(:x, [2]) & p.eq(:y, :z) }
+
+      it 'works as expected' do
+        expect(subject).to eql(predicate)
+      end
+    end
+
+  end
+end

data/spec/sequel/test_to_sequel.rb

@@ -164,6 +164,22 @@ class Predicate
       end
     end
 
+    context 'subset' do
+      let(:predicate) { Predicate.subset(:x, [8, 9]) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(NotSupportedError)
+      end
+    end
+
+    context 'superset' do
+      let(:predicate) { Predicate.superset(:x, [8, 9]) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(NotSupportedError)
+      end
+    end
+
     context 'match' do
       let(:predicate) { Predicate.match(left, right, options) }
       let(:options){ nil }