predicate 2.8.0 → 2.10.0

data/spec/predicate/test_coerce.rb

@@ -7,39 +7,41 @@ class Predicate
     describe "from Predicate" do
       let(:arg){ Predicate.new(Factory.tautology) }
 
-      it{ should be(arg) }
+      it {
+        expect(subject).to be(arg)
+      }
     end
 
     describe "from true" do
       let(:arg){ true }
 
-      specify{
-        subject.expr.should be_a(Tautology)
+      specify {
+        expect(subject.expr).to be_a(Tautology)
       }
     end
 
     describe "from false" do
       let(:arg){ false }
 
-      specify{
-        subject.expr.should be_a(Contradiction)
+      specify {
+        expect(subject.expr).to be_a(Contradiction)
       }
     end
 
     describe "from Symbol" do
       let(:arg){ :status }
 
-      specify{
-        subject.expr.should be_a(Identifier)
-        subject.expr.name.should eq(arg)
+      specify {
+        expect(subject.expr).to be_a(Identifier)
+        expect(subject.expr.name).to eq(arg)
       }
     end
 
     describe "from Proc" do
       let(:arg){ lambda{ status == 10 } }
 
-      specify{
-        subject.expr.should be_a(Native)
+      specify {
+        expect(subject.expr).to be_a(Native)
       }
     end
 
@@ -47,25 +49,25 @@ class Predicate
       let(:arg){ "status == 10" }
 
       it 'raises an error' do
-        lambda{
+        expect{
           subject
-        }.should raise_error(ArgumentError)
+        }.to raise_error(ArgumentError)
       end
     end
 
     describe "from Hash (single)" do
       let(:arg){ {status: 10} }
 
-      specify{
-        subject.expr.should be_a(Eq)
-        subject.expr.should eq([:eq, [:identifier, :status], [:literal, 10]])
+      specify {
+        expect(subject.expr).to be_a(Eq)
+        expect(subject.expr).to eq([:eq, [:identifier, :status], [:literal, 10]])
       }
     end
 
     describe "from Hash (multiple)" do
       let(:arg){ {status: 10, name: "Jones"} }
 
-      specify{
+      specify {
         expect(subject).to eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
       }
     end
@@ -73,7 +75,7 @@ class Predicate
     describe "from Hash (in)" do
       let(:arg){ {status: [10, 15]} }
 
-      specify{
+      specify {
         expect(subject).to eq(Predicate.in(:status, [10,15]))
       }
     end

data/spec/predicate/test_constants.rb

@@ -8,157 +8,209 @@ class Predicate
     context "on tautology" do
       let(:pred){ p.tautology }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on contradiction" do
       let(:pred){ p.contradiction }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on eq(identifier,value)" do
       let(:pred){ p.eq(:x, 2) }
 
-      it{ should eq({x: 2}) }
+      it {
+        expect(subject).to eq({x: 2})
+      }
     end
 
     context "on eq(identifier,placeholder)" do
       let(:pred){ p.eq(:x, p.placeholder) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on eq(value,identifier)" do
       let(:pred){ p.eq(2, :x) }
 
-      it{ should eq({x: 2}) }
+      it {
+        expect(subject).to eq({x: 2})
+      }
     end
 
     context "on eq(identifier,identifier)" do
       let(:pred){ p.eq(:x, :y) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on not" do
       let(:pred){ !p.eq(:x, 2) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on neq" do
       let(:pred){ p.neq(:x, 2) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on gt" do
       let(:pred){ p.gt(:x, 2) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on in (singleton)" do
       let(:pred){ p.in(:x, [2]) }
 
-      it{ should eq({x: 2}) }
+      it {
+        expect(subject).to eq({x: 2})
+      }
     end
 
     context "on in (multiples)" do
       let(:pred){ p.in(:x, [2, 3]) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on in (opaque)" do
       let(:pred){ p.in(:x, p.opaque([2])) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on and (two eqs)" do
       let(:pred){ p.eq(:x, 2) & p.eq(:y, 4) }
 
-      it{ should eq({x: 2, y: 4}) }
+      it {
+        expect(subject).to eq({x: 2, y: 4})
+      }
     end
 
     context "on and (one eq)" do
       let(:pred){ p.eq(:x, 2) & p.in(:y, [4,8]) }
 
-      it{ should eq({x: 2}) }
+      it {
+        expect(subject).to eq({x: 2})
+      }
     end
 
     context "on and (one eq, one in, same variable)" do
       let(:pred){ p.in(:x, [2,8]) & p.eq(:x, 2) }
 
-      it{ should eq({x: 2}) }
+      it {
+        expect(subject).to eq({x: 2})
+      }
     end
 
     context "on and (one eq, one in, yielding contradiction)" do
       let(:pred){ p.in(:x, [3,8]) & p.eq(:x, 2) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on and (contradiction)" do
       let(:pred){ p.eq(:x, 2) & p.eq(:x, 4) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on intersect" do
       let(:pred){ p.intersect(:x, [4,8]) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on intersect with placeholder" do
       let(:pred){ p.intersect(:x, p.placeholder) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on subset" do
       let(:pred){ p.subset(:x, [4,8]) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on subset with placeholder" do
       let(:pred){ p.subset(:x, p.placeholder) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on superset" do
       let(:pred){ p.superset(:x, [4,8]) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on superset with placeholder" do
       let(:pred){ p.superset(:x, p.placeholder) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on or (two eqs)" do
       let(:pred){ p.eq(:x, 2) | p.eq(:y, 4) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on match" do
       let(:pred){ p.match(:x, "London") }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
     context "on native" do
       let(:pred){ p.native(->(t){}) }
 
-      it{ should eq({}) }
+      it {
+        expect(subject).to eq({})
+      }
     end
 
   end

data/spec/predicate/test_free_variables.rb

@@ -7,7 +7,9 @@ class Predicate
     describe "on a comp(:eq)" do
       let(:p){ Predicate.coerce(:x => 2) }
 
-      it{ should eq([:x]) }
+      it {
+        expect(subject).to eq([:x])
+      }
     end
 
   end

data/spec/predicate/test_hash_and_equal.rb

@@ -5,21 +5,25 @@ class Predicate
     subject{ left == right }
 
     after do
-      left.hash.should eq(right.hash) if subject
+      expect(left.hash).to eq(right.hash) if subject
     end
 
     describe "on equal predicates" do
       let(:left) { Predicate.coerce(:x => 2) }
       let(:right){ Predicate.coerce(:x => 2) }
 
-      it{ should be(true) }
+      it {
+        expect(subject).to be(true)
+      }
     end
 
     describe "on non equal predicates" do
       let(:left) { Predicate.coerce(:x => 2) }
       let(:right){ Predicate.coerce(:x => 3) }
 
-      it{ should be(false) }
+      it {
+        expect(subject).to be(false)
+      }
     end
 
   end

data/spec/predicate/test_qualify.rb

@@ -24,12 +24,14 @@ class Predicate
       context 'on a full AST predicate' do
         let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
 
-        it{ should eq(p.in(Factory.qualified_identifier(:t, :x), [2]) & p.eq(:y, 3)) }
+        it {
+          expect(subject).to eq(p.in(Factory.qualified_identifier(:t, :x), [2]) & p.eq(:y, 3))
+        }
 
         specify "it should tag expressions correctly" do
-          subject.expr.should be_a(Sexpr)
-          subject.expr.should be_a(Expr)
-          subject.expr.should be_a(And)
+          expect(subject.expr).to be_a(Sexpr)
+          expect(subject.expr).to be_a(Expr)
+          expect(subject.expr).to be_a(And)
         end
       end
 
@@ -37,9 +39,9 @@ class Predicate
         let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
 
         it 'raises an error' do
-          lambda{
+          expect{
             subject
-          }.should raise_error(NotSupportedError)
+          }.to raise_error(NotSupportedError)
         end
       end
     end

data/spec/predicate/test_rename.rb

@@ -12,12 +12,14 @@ class Predicate
       context 'on a full AST predicate' do
         let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
 
-        it{ should eq(p.in(:z, [2]) & p.eq(:y, 3)) }
+        it {
+          expect(subject).to eq(p.in(:z, [2]) & p.eq(:y, 3))
+        }
 
         specify "it should tag expressions correctly" do
-          subject.expr.should be_a(Sexpr)
-          subject.expr.should be_a(Expr)
-          subject.expr.should be_a(And)
+          expect(subject.expr).to be_a(Sexpr)
+          expect(subject.expr).to be_a(Expr)
+          expect(subject.expr).to be_a(And)
         end
       end
 
@@ -25,9 +27,9 @@ class Predicate
         let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
 
         it 'raises an error' do
-          lambda{
+          expect{
             subject
-          }.should raise_error(NotSupportedError)
+          }.to raise_error(NotSupportedError)
         end
       end
 
@@ -35,7 +37,7 @@ class Predicate
         let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 3) }
 
         it 'renames correctly' do
-          subject.should eq(p.eq(Factory.qualified_identifier(:t, :z), 3))
+          expect(subject).to eq(p.eq(Factory.qualified_identifier(:t, :z), 3))
         end
       end
     end
@@ -46,13 +48,17 @@ class Predicate
       context "on an identifier" do
         let(:predicate){ p.eq(:x, 2) }
 
-        it{ should eq(p.eq(:y, 2)) }
+        it {
+          expect(subject).to eq(p.eq(:y, 2))
+        }
       end
 
       context "on a qualifier identifier" do
         let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
 
-        it{ should eq(p.eq(:y, 2)) }
+        it {
+          expect(subject).to eq(p.eq(:y, 2))
+        }
       end
     end
 
@@ -62,13 +68,17 @@ class Predicate
       context 'on an identifier' do
         let(:predicate){ p.eq(:x, 2) }
 
-        it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
+        it {
+          expect(subject).to eq(p.eq(Factory.qualified_identifier(:t, :y), 2))
+        }
       end
 
       context 'on a qualified' do
         let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
 
-        it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
+        it {
+          expect(subject).to eq(p.eq(Factory.qualified_identifier(:t, :y), 2))
+        }
       end
     end
 

data/spec/predicate/test_to_hashes.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "to_hashes" do
+
+    let(:p){ Predicate }
+
+    subject{ predicate.to_hashes }
+
+    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 "neq" do
+      let(:predicate){ Predicate.neq(: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
+
+    context "and with a neq" do
+      let(:predicate){ Predicate.neq(:x, 3) & Predicate.in(:y, [2,3]) }
+
+      it{ expect(subject).to eql([{y: [2,3]},{x: 3}]) }
+    end
+
+    context "not nil & eq" do
+      let(:predicate){ Predicate.neq(:x, nil) & Predicate.eq(:x, [2,3]) }
+
+      it{ expect(subject).to eql([{x: [2,3]},{x: nil}]) }
+    end
+
+    ## unsupported
+
+    context "not" do
+      let(:predicate){ Predicate.not(Predicate.eq(:x, 2)) }
+
+      it{ expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+    context "not-and" do
+      let(:predicate){ Predicate.not(Predicate.eq(:x, 3) & Predicate.in(:y, [2,3])) }
+
+      it{ expect{ subject }.to raise_error(ArgumentError) }
+    end
+
+  end
+end

data/spec/sequel/test_to_sequel.rb

@@ -101,21 +101,6 @@ class Predicate
       end
     end
 
-    context 'in with something responding to sql_literal' do
-      let(:operand){
-        Object.new.tap{|o|
-          def o.sql_literal(db)
-            "Hello World"
-          end
-        }
-      }
-      let(:predicate) { Predicate.in(:price, Predicate.opaque(operand)) }
-
-      it 'works as expected' do
-        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` IN (Hello World))")
-      end
-    end
-
     context 'not' do
       let(:predicate) { !Predicate.in(:price, [10.0, 17.99]) }
 
@@ -136,7 +121,6 @@ class Predicate
       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
@@ -221,5 +205,43 @@ class Predicate
         expect { subject }.to raise_error(NotSupportedError)
       end
     end
+
+    class SqlAble
+      def initialize(value)
+        @value = value
+      end
+
+      def sql(*args, &bl)
+        @value
+      end
+      alias :sql_literal :sql
+    end
+
+    context 'opaque in an IN' do
+      let(:operand) {
+        SqlAble.new('Hello World')
+      }
+      let(:predicate) {
+        Predicate.in(:price, Predicate.opaque(operand))
+      }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` IN (Hello World))")
+      end
+    end
+
+    context 'native' do
+      let(:operand) {
+        SqlAble.new(Sequel.lit("1=1"))
+      }
+      let(:predicate) {
+        Predicate.native(operand)
+      }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (1=1)")
+      end
+    end
+
   end
 end

data/spec/shared/a_predicate.rb

@@ -5,30 +5,30 @@ shared_examples_for "a predicate" do
   let(:y){ 13 }
 
   it 'is a Predicate' do
-    subject.should be_a(Predicate)
+    expect(subject).to be_a(Predicate)
   end
 
   it 'can be negated easily' do
-    (!subject).should be_a(Predicate)
+    expect(!subject).to be_a(Predicate)
   end
 
   it 'detects stupid AND' do
-    (subject & Predicate.tautology).should be(subject)
+    expect(subject & Predicate.tautology).to be(subject)
   end
 
   it 'detects stupid OR' do
-    (subject | Predicate.contradiction).should be(subject)
+    expect(subject | Predicate.contradiction).to be(subject)
   end
 
   it 'has free variables' do
-    (fv = subject.free_variables).should be_a(Array)
-    (fv - [ :w, :x, :y ]).should be_empty
+    expect(fv = subject.free_variables).to be_a(Array)
+    expect(fv - [ :w, :x, :y ]).to 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)
+    expect(top).to be_tautology
+    expect(down).to eq(subject)
   end
 
 end

data/spec/spec_helper.rb

@@ -26,4 +26,5 @@ end
 RSpec.configure do |c|
   c.include Helpers
   c.extend  Helpers
+  c.raise_errors_for_deprecations!
 end

data/spec/test_readme.rb

@@ -49,7 +49,7 @@ describe "README" do
         { name: "Candy", price: 6 },
         { name: "Crush", price: 4 }
       ]
-    })).to eql(true)    
+    })).to eql(true)
   end
 
   it 'has a correct sixth example' do