predicate 2.7.1 → 2.9.0

data/spec/predicate/test_bool_not.rb

@@ -7,61 +7,81 @@ class Predicate
     context "on tautology" do
       let(:pred){ Predicate.tautology }
 
-      it{ should eq(Predicate.contradiction) }
+      it {
+        expect(subject).to eq(Predicate.contradiction)
+      }
     end
 
     context "on contradiction" do
       let(:pred){ Predicate.contradiction }
 
-      it{ should eq(Predicate.tautology) }
+      it {
+        expect(subject).to eq(Predicate.tautology)
+      }
     end
 
     context "on not" do
       let(:pred){ Predicate.not(:x) }
 
-      it{ should eq(Predicate.identifier(:x)) }
+      it {
+        expect(subject).to eq(Predicate.identifier(:x))
+      }
     end
 
     context "on comp" do
       let(:pred){ Predicate.comp(:eq, :x => 2) }
 
-      it{ should eq(Predicate.comp(:neq, :x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.comp(:neq, :x => 2))
+      }
     end
 
     context "on eq" do
       let(:pred){ Predicate.eq(:x => 2) }
 
-      it{ should eq(Predicate.neq(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.neq(:x => 2))
+      }
     end
 
     context "on neq" do
       let(:pred){ Predicate.neq(:x => 2) }
 
-      it{ should eq(Predicate.eq(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.eq(:x => 2))
+      }
     end
 
     context "on lt" do
       let(:pred){ Predicate.lt(:x => 2) }
 
-      it{ should eq(Predicate.gte(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.gte(:x => 2))
+      }
     end
 
     context "on lte" do
       let(:pred){ Predicate.lte(:x => 2) }
 
-      it{ should eq(Predicate.gt(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.gt(:x => 2))
+      }
     end
 
     context "on gt" do
       let(:pred){ Predicate.gt(:x => 2) }
 
-      it{ should eq(Predicate.lte(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.lte(:x => 2))
+      }
     end
 
     context "on gte" do
       let(:pred){ Predicate.gte(:x => 2) }
 
-      it{ should eq(Predicate.lt(:x => 2)) }
+      it {
+        expect(subject).to eq(Predicate.lt(:x => 2))
+      }
     end
 
   end

data/spec/predicate/test_bool_or.rb

@@ -7,19 +7,23 @@ class Predicate
     subject{ left | right }
 
     before do
-      subject.should be_a(Predicate)
+      expect(subject).to be_a(Predicate)
     end
 
     context 'with itself' do
       let(:right){ left }
 
-      it{ should be(left) }
+      it {
+        expect(subject).to be(left)
+      }
     end
 
     context 'with the same expression' do
       let(:right){ Predicate.coerce(x: 2) }
 
-      it{ should be(left) }
+      it {
+        expect(subject).to be(left)
+      }
     end
 
   end

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

@@ -136,7 +136,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

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