predicate 2.3.3 → 2.7.0

data/spec/postgres/test_to_postgres.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+class Predicate
+  describe 'to_postgres' do
+    subject {
+      predicate.to_postgres
+    }
+
+    context 'on an intersect' do
+      let(:predicate){
+        Predicate.intersect(:x, [1, 2, 3])
+      }
+
+      it 'returns another predicate' do
+        expect(subject).to be_a(Predicate)
+      end
+
+      it 'replaces intersect by pg_array_overlaps' do
+        expect(subject.sexpr).to eql([
+          :pg_array_overlaps,
+          [ :identifier, :x ],
+          [ :pg_array_literal, [1, 2, 3], :varchar ]
+        ])
+      end
+    end
+
+    context 'on an intersect' do
+      let(:predicate){
+        Predicate.empty(:x)
+      }
+
+      it 'replaces empty by pg_array_empty' do
+        expect(subject.sexpr).to eql([
+          :pg_array_empty,
+          [ :identifier, :x ],
+          :varchar
+        ])
+      end
+    end
+  end
+end

data/spec/postgres/test_to_sequel.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+class Predicate
+  describe ToSequel do
+    PG_DB = Sequel.connect(ENV['PREDICATE_PG_URL'])
+
+    before(:all) do
+      create_items_database(PG_DB)
+      items = PG_DB[:items]
+    end
+
+    subject do
+      dataset = PG_DB[:items].where(predicate.to_postgres.to_sequel)
+      dataset
+    end
+
+    # after do
+    #   subject.to_a
+    # end
+
+    context 'tautology' do
+      let(:predicate) { Predicate.tautology }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE true})
+      end
+    end
+
+    context 'intersect' do
+      let(:predicate) { Predicate.intersect(:x, [1, 2, 3]) }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE ("x" && ARRAY[1,2,3])})
+      end
+    end
+
+    context 'empty' do
+      let(:predicate) { Predicate.empty(:x) }
+
+      it 'works as expected' do
+        expect(subject.sql).to eql(%Q{SELECT * FROM "items" WHERE ("x" = '{}'::varchar[])})
+      end
+    end
+  end if ENV['PREDICATE_PG_URL']
+end

data/spec/predicate/test_and_split.rb

@@ -83,5 +83,23 @@ class Predicate
       it{ should eq([ pred, p.tautology ]) }
     end
 
+    context "on intersect" do
+      let(:pred){ p.intersect(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on subset" do
+      let(:pred){ p.subset(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [1, 2]) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
   end
 end

data/spec/predicate/test_attr_split.rb

@@ -47,6 +47,24 @@ class Predicate
       it{ should eq({ x: pred }) }
     end
 
+    context "on intersect" do
+      let(:pred){ p.intersect(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on subset" do
+      let(:pred){ p.subset(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
+    context "on superset" do
+      let(:pred){ p.superset(:x, [2]) }
+
+      it{ should eq({ x: pred }) }
+    end
+
     context "on match" do
       let(:pred){ p.match(:x, "London") }
 

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/sequel/test_to_sequel.rb

@@ -1,19 +1,11 @@
 require 'spec_helper'
-require 'sequel'
-require 'sqlite3'
-require 'predicate/sequel'
 class Predicate
   describe ToSequel do
 
     DB = Sequel.sqlite
 
     before(:all) do
-      DB.create_table :items do
-        primary_key :id
-        String :name
-        String :address
-        Float :price
-      end
+      create_items_database(DB)
       items = DB[:items]
     end
 
@@ -140,6 +132,15 @@ class Predicate
       end
     end
 
+    context 'nary and' do
+      let(:predicate) { Predicate.eq(:name, "Bob") & Predicate.eq(:price, 10.0) & Predicate.eq(:city, "London") }
+
+      it 'works as expected' do
+        puts predicate.sexpr.inspect
+        expect(subject).to eql("SELECT * FROM `items` WHERE ((`name` = 'Bob') AND (`price` = 10.0) AND (`city` = 'London'))")
+      end
+    end
+
     context 'or' do
       let(:predicate) { Predicate.eq(:name, "Bob") | Predicate.lt(:price, 10.0) }
 
@@ -164,6 +165,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 }
@@ -204,6 +221,5 @@ class Predicate
         expect { subject }.to raise_error(NotSupportedError)
       end
     end
-
   end
 end

data/spec/shared/a_predicate.rb

@@ -0,0 +1,34 @@
+shared_examples_for "a predicate" do
+
+  let(:w){ [8, 9] }
+  let(:x){ 12 }
+  let(:y){ 13 }
+
+  it 'is a Predicate' do
+    subject.should be_a(Predicate)
+  end
+
+  it 'can be negated easily' do
+    (!subject).should be_a(Predicate)
+  end
+
+  it 'detects stupid AND' do
+    (subject & Predicate.tautology).should be(subject)
+  end
+
+  it 'detects stupid OR' do
+    (subject | Predicate.contradiction).should be(subject)
+  end
+
+  it 'has free variables' do
+    (fv = subject.free_variables).should be_a(Array)
+    (fv - [ :w, :x, :y ]).should be_empty
+  end
+
+  it 'always splits around and trivially when no free variables are touched' do
+    top, down = subject.and_split([:z])
+    top.should be_tautology
+    down.should eq(subject)
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,9 +1,26 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require "rspec"
+require 'rspec'
+require 'sequel'
+require 'sqlite3'
+require 'pg'
 require 'predicate'
+require 'predicate/sequel'
+require 'predicate/postgres'
+require_relative 'shared/a_predicate'
 
+Sequel.extension :pg_array, :pg_array_ops
 module Helpers
 
+  def create_items_database(db)
+    db.drop_table? :items
+    db.create_table :items do
+      primary_key :id
+      String :name
+      String :address
+      Float :price
+    end
+  end
+
 end
 
 RSpec.configure do |c|