predicate 2.8.0 → 2.9.0

data/spec/factory/test_not.rb

@@ -6,8 +6,12 @@ class Predicate
     subject{ self.not(true) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Not) }
-    it{ should eql([:not, tautology]) }
+    it {
+      expect(subject).to be_a(Not)
+    }
+    it {
+      expect(subject).to eql([:not, tautology])
+    }
 
   end
 end

data/spec/factory/test_or.rb

@@ -6,8 +6,12 @@ class Predicate
     subject{ self.or(true, true) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Or) }
-    it{ should eql([:or, tautology, tautology]) }
+    it {
+      expect(subject).to be_a(Or)
+    }
+    it {
+      expect(subject).to eql([:or, tautology, tautology])
+    }
 
   end
 end

data/spec/factory/test_qualified_identifier.rb

@@ -7,9 +7,13 @@ class Predicate
 
     it_should_behave_like "a predicate AST node"
 
-    it{ should be_a(QualifiedIdentifier) }
+    it{
+      expect(subject).to be_a(QualifiedIdentifier)
+    }
 
-    it{ should eql([:qualified_identifier, :t, :name]) }
+    it{
+      expect(subject).to eql([:qualified_identifier, :t, :name])
+    }
 
   end
 end

data/spec/factory/test_set_ops.rb

@@ -9,9 +9,13 @@ class Predicate
 
       subject{ Factory.send(op_name, :x, [2, 3]) }
 
-      it{ should be_a(op_class) }
+      it {
+        expect(subject).to be_a(op_class)
+      }
 
-      it{ should eq([op_name, [:identifier, :x], [:literal, [2, 3]]]) }
+      it {
+        expect(subject).to eq([op_name, [:identifier, :x], [:literal, [2, 3]]])
+      }
 
     end
   end

data/spec/factory/test_tautology.rb

@@ -6,7 +6,9 @@ class Predicate
     subject{ tautology }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Tautology) }
+    it {
+      expect(subject).to be_a(Tautology)
+    }
 
   end
 end

data/spec/factory/test_var.rb

@@ -7,16 +7,24 @@ class Predicate
       subject{ var("a.b.c", :dig) }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(Var) }
-      it{ should eql([:var, "a.b.c", :dig]) }
+      it {
+        expect(subject).to be_a(Var)
+      }
+      it {
+        expect(subject).to eql([:var, "a.b.c", :dig])
+      }
     end
 
     context 'when used with an array' do
       subject{ var([:a, :b, :c], :dig) }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(Var) }
-      it{ should eql([:var, [:a, :b, :c], :dig]) }
+      it {
+        expect(subject).to be_a(Var)
+      }
+      it {
+        expect(subject).to eql([:var, [:a, :b, :c], :dig])
+      }
     end
   end
 end

data/spec/grammar/test_match.rb

@@ -6,10 +6,10 @@ class Predicate
       subject{ Grammar[:tautology] }
 
       it 'matches a tautology' do
-        subject.should be_match([:tautology, true])
+        expect(subject).to be_match([:tautology, true])
       end
       it 'does no match a wrong one' do
-        subject.should_not be_match([:tautology, false])
+        expect(subject).not_to be_match([:tautology, false])
       end
     end
 
@@ -17,10 +17,10 @@ class Predicate
       subject{ Grammar[:contradiction] }
 
       it 'matches a tautology' do
-        subject.should be_match([:contradiction, false])
+        expect(subject).to be_match([:contradiction, false])
       end
       it 'does no match a wrong one' do
-        subject.should_not be_match([:contradiction, true])
+        expect(subject).not_to be_match([:contradiction, true])
       end
     end
 
@@ -28,11 +28,11 @@ class Predicate
       subject{ Grammar[:identifier] }
 
       it 'matches a valid ast' do
-        subject.should be_match([:identifier, :id])
+        expect(subject).to be_match([:identifier, :id])
       end
 
       it 'does not match an invalid ast' do
-        subject.should_not be_match([:identifier, 12])
+        expect(subject).not_to be_match([:identifier, 12])
       end
     end
 
@@ -40,8 +40,8 @@ class Predicate
       subject{ Grammar[:literal] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:literal, 12])
-        subject.should be_match([:literal, true])
+        expect(subject).to be_match([:literal, 12])
+        expect(subject).to be_match([:literal, true])
       end
     end
 
@@ -49,10 +49,10 @@ class Predicate
       subject{ Grammar[:in] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:in, [:identifier, :x], [2, 3]])
+        expect(subject).to be_match([:in, [:identifier, :x], [2, 3]])
       end
       it 'does not match invalid ASTs' do
-        subject.should_not be_match([:in, :x])
+        expect(subject).not_to be_match([:in, :x])
       end
     end
 
@@ -60,10 +60,10 @@ class Predicate
       subject{ Grammar[:eq] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:eq, [:identifier, :age], [:literal, 12]])
+        expect(subject).to be_match([:eq, [:identifier, :age], [:literal, 12]])
       end
       it 'does not match invalid ASTs' do
-        subject.should_not be_match([:neq, [:identifier, :age], [:literal, 12]])
+        expect(subject).not_to be_match([:neq, [:identifier, :age], [:literal, 12]])
       end
     end
 
@@ -71,10 +71,10 @@ class Predicate
       subject{ Grammar[:neq] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:neq, [:identifier, :age], [:literal, 12]])
+        expect(subject).to be_match([:neq, [:identifier, :age], [:literal, 12]])
       end
       it 'does not match invalid ASTs' do
-        subject.should_not be_match([:eq, [:identifier, :age], [:literal, 12]])
+        expect(subject).not_to be_match([:eq, [:identifier, :age], [:literal, 12]])
       end
     end
 
@@ -82,11 +82,11 @@ class Predicate
       subject{ Grammar[:match] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:match, [:identifier, :name], [:literal, "London"], {}])
-        subject.should be_match([:match, [:identifier, :name], [:literal, /London/], {}])
+        expect(subject).to be_match([:match, [:identifier, :name], [:literal, "London"], {}])
+        expect(subject).to be_match([:match, [:identifier, :name], [:literal, /London/], {}])
       end
       it 'does not match invalid ASTs' do
-        subject.should_not be_match([:native, 12])
+        expect(subject).not_to be_match([:native, 12])
       end
     end
 
@@ -94,10 +94,10 @@ class Predicate
       subject{ Grammar[:native] }
 
       it 'matches valid ASTs' do
-        subject.should be_match([:native, lambda{}])
+        expect(subject).to be_match([:native, lambda{}])
       end
       it 'does not match invalid ASTs' do
-        subject.should_not be_match([:native, 12])
+        expect(subject).not_to be_match([:native, 12])
       end
     end
 

data/spec/grammar/test_sexpr.rb

@@ -17,103 +17,135 @@ class Predicate
     }
 
     before do
-      subject.should be_a(Sexpr)
+      expect(subject).to be_a(Sexpr)
     end
 
     describe "tautology" do
       let(:expr){ [:tautology, true] }
 
-      it{ should be_a(Tautology) }
+      it {
+        expect(subject).to be_a(Tautology)
+      }
     end
 
     describe "contradiction" do
       let(:expr){ [:contradiction, false] }
 
-      it{ should be_a(Contradiction) }
+      it {
+        expect(subject).to be_a(Contradiction)
+      }
     end
 
     describe "identifier" do
       let(:expr){ [:identifier, :name] }
 
-      it{ should be_a(Identifier) }
+      it {
+        expect(subject).to be_a(Identifier)
+      }
     end
 
     describe "and" do
       let(:expr){ [:and, contradiction, contradiction] }
 
-      it{ should be_a(And) }
+      it {
+        expect(subject).to be_a(And)
+      }
     end
 
     describe "or" do
       let(:expr){ [:or, contradiction, contradiction] }
 
-      it{ should be_a(Or) }
+      it {
+        expect(subject).to be_a(Or)
+      }
     end
 
     describe "not" do
       let(:expr){ [:not, contradiction] }
 
-      it{ should be_a(Not) }
+      it {
+        expect(subject).to be_a(Not)
+      }
     end
 
     describe "eq" do
       let(:expr){ [:eq, identifier, identifier] }
 
-      it{ should be_a(Eq) }
+      it {
+        expect(subject).to be_a(Eq)
+      }
     end
 
     describe "neq" do
       let(:expr){ [:neq, identifier, identifier] }
 
-      it{ should be_a(Neq) }
+      it {
+        expect(subject).to be_a(Neq)
+      }
     end
 
     describe "gt" do
       let(:expr){ [:gt, identifier, identifier] }
 
-      it{ should be_a(Gt) }
+      it {
+        expect(subject).to be_a(Gt)
+      }
     end
 
     describe "gte" do
       let(:expr){ [:gte, identifier, identifier] }
 
-      it{ should be_a(Gte) }
+      it {
+        expect(subject).to be_a(Gte)
+      }
     end
 
     describe "lt" do
       let(:expr){ [:lt, identifier, identifier] }
 
-      it{ should be_a(Lt) }
+      it {
+        expect(subject).to be_a(Lt)
+      }
     end
 
     describe "lte" do
       let(:expr){ [:lte, identifier, identifier] }
 
-      it{ should be_a(Lte) }
+      it {
+        expect(subject).to be_a(Lte)
+      }
     end
 
     describe "in" do
       let(:expr){ [:in, identifier, values] }
 
-      it{ should be_a(In) }
+      it {
+        expect(subject).to be_a(In)
+      }
     end
 
     describe "intersect" do
       let(:expr){ [:intersect, identifier, values] }
 
-      it{ should be_a(Intersect) }
+      it {
+        expect(subject).to be_a(Intersect)
+      }
     end
 
     describe "literal" do
       let(:expr){ [:literal, 12] }
 
-      it{ should be_a(Literal) }
+      it {
+        expect(subject).to be_a(Literal)
+      }
     end
 
     describe "native" do
       let(:expr){ [:native, lambda{}] }
 
-      it{ should be_a(Native) }
+      it {
+        expect(subject).to be_a(Native)
+      }
     end
 
   end

data/spec/nodes/and/test_and_split.rb

@@ -12,19 +12,25 @@ class Predicate
       context 'when fully covered' do
         let(:list){ [:x, :y] }
 
-        it{ should eq([predicate, tautology]) }
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
 
       context 'when not covered at all' do
         let(:list){ [:name] }
 
-        it{ should eq([tautology, predicate]) }
+        it {
+          expect(subject).to eq([tautology, predicate])
+        }
       end
 
       context 'when partially covered' do
         let(:list){ [:x] }
 
-        it{ should eq([Factory.eq(:x, 2), Factory.eq(:y, 3)]) }
+        it {
+          expect(subject).to eq([Factory.eq(:x, 2), Factory.eq(:y, 3)])
+        }
       end
     end
 
@@ -34,31 +40,41 @@ class Predicate
       context 'when fully covered' do
         let(:list){ [:x, :y, :z] }
 
-        it{ should eq([predicate, tautology]) }
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
 
       context 'when not covered at all' do
         let(:list){ [:name] }
 
-        it{ should eq([tautology, predicate]) }
+        it {
+          expect(subject).to eq([tautology, predicate])
+        }
       end
 
       context 'when partially covered but split-able' do
         let(:list){ [:x] }
 
-        it{ should eq([Factory.eq(:x, 2), Factory.eq(:y, :z)]) }
+        it {
+          expect(subject).to eq([Factory.eq(:x, 2), Factory.eq(:y, :z)])
+        }
       end
 
       context 'when partially covered but split-able (2)' do
         let(:list){ [:y] }
 
-        it{ should eq([Factory.eq(:y, :z), Factory.eq(:x, 2)]) }
+        it {
+          expect(subject).to eq([Factory.eq(:y, :z), Factory.eq(:x, 2)])
+        }
       end
 
       context 'when partially covered but not split-able' do
         let(:list){ [:x, :y] }
 
-        it{ should eq([predicate, tautology]) }
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
     end
 
@@ -70,13 +86,17 @@ class Predicate
       context 'when fully covered' do
         let(:list){ [:x, :y, :z] }
 
-        it{ should eq([predicate, tautology]) }
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
 
       context 'when not covered' do
         let(:list){ [:y] }
 
-        it{ should eq([right, left]) }
+        it {
+          expect(subject).to eq([right, left])
+        }
       end
     end
 

data/spec/nodes/dyadic_comp/test_and_split.rb

@@ -10,13 +10,17 @@ class Predicate
     context 'when included' do
       let(:list){ [:id, :name] }
 
-      it{ should eq([predicate, tautology]) }
+      it {
+        expect(subject).to eq([predicate, tautology])
+      }
     end
 
     context 'when not include' do
       let(:list){ [:name] }
 
-      it{ should eq([tautology, predicate]) }
+      it {
+        expect(subject).to eq([tautology, predicate])
+      }
     end
 
     context 'with attributes on both sides' do
@@ -24,20 +28,26 @@ class Predicate
 
       context 'when full at left' do
         let(:list){ [:x, :y] }
-      
-        it{ should eq([predicate, tautology]) }
+
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
-      
+
       context 'none at left' do
         let(:list){ [] }
-      
-        it{ should eq([tautology, predicate]) }
+
+        it {
+          expect(subject).to eq([tautology, predicate])
+        }
       end
 
       context 'mix' do
         let(:list){ [:y] }
 
-        it{ should eq([predicate, tautology]) }
+        it {
+          expect(subject).to eq([predicate, tautology])
+        }
       end
     end
 

data/spec/nodes/eq/test_and.rb

@@ -11,25 +11,33 @@ class Predicate
     context 'with an eq leading to a contradiction' do
       let(:right){ Factory.eq(:x, 3) }
 
-      it{ should be_a(Contradiction) }
+      it{
+        expect(subject).to be_a(Contradiction)
+      }
     end
 
     context 'with an IN on same variable and literal' do
       let(:right){ Factory.in(:x, [2,4]) }
 
-      it{ should be(left) }
+      it{
+        expect(subject).to be(left)
+      }
     end
 
     context 'with an IN on same variable and opaque' do
       let(:right){ Factory.in(:x, Factory.opaque([3,4])) }
 
-      it{ should be_a(And) }
+      it{
+        expect(subject).to be_a(And)
+      }
     end
 
     context 'with an IN having a placeholder' do
       let(:right){ Factory.in(:x, Factory.placeholder) }
 
-      it{ should be_a(And) }
+      it{
+        expect(subject).to be_a(And)
+      }
     end
 
   end

data/spec/nodes/identifier/test_and_split.rb

@@ -10,13 +10,17 @@ class Predicate
     context 'when included' do
       let(:list){ [:id, :name] }
 
-      it{ should eq([predicate, tautology]) }
+      it {
+        expect(subject).to eq([predicate, tautology])
+      }
     end
 
     context 'when not include' do
       let(:list){ [:name] }
 
-      it{ should eq([tautology, predicate]) }
+      it {
+        expect(subject).to eq([tautology, predicate])
+      }
     end
 
   end

data/spec/nodes/identifier/test_free_variables.rb

@@ -6,7 +6,9 @@ class Predicate
 
     subject{ expr.free_variables }
 
-    it{ should eq([:id]) }
+    it {
+      expect(subject).to eq([:id])
+    }
 
   end
 end

data/spec/nodes/identifier/test_name.rb

@@ -6,7 +6,9 @@ class Predicate
 
     subject{ expr.name }
 
-    it{ should eq(:id) }
+    it {
+      expect(subject).to eq(:id)
+    }
 
   end
 end

data/spec/nodes/in/test_and.rb

@@ -11,37 +11,49 @@ class Predicate
     context 'with an eq on same variable' do
       let(:right){ Factory.eq(:x, 2) }
 
-      it{ should be(right) }
+      it {
+        expect(subject).to be(right)
+      }
     end
 
     context 'with an eq on same variable yielding a contradiction' do
       let(:right){ Factory.eq(:x, 3) }
 
-      it{ should eql(Factory.contradiction) }
+      it {
+        expect(subject).to eql(Factory.contradiction)
+      }
     end
 
     context 'with an in on same variable' do
       let(:right){ Factory.in(:x, [2, 4, 5]) }
 
-      it{ should eql(Factory.in(:x, [2, 4])) }
+      it {
+        expect(subject).to eql(Factory.in(:x, [2, 4]))
+      }
     end
 
     context 'with an in on same variable, leading to a singleton' do
       let(:right){ Factory.in(:x, [2]) }
 
-      it{ should eql(Factory.eq(:x, 2)) }
+      it {
+        expect(subject).to eql(Factory.eq(:x, 2))
+      }
     end
 
     context 'with an eq on same variable, leading to a singleton' do
       let(:right){ Factory.in(:x, [2, 5]) }
 
-      it{ should eql(Factory.eq(:x, 2)) }
+      it {
+        expect(subject).to eql(Factory.eq(:x, 2))
+      }
     end
 
     context 'with an in on same variable, leading to a empty set' do
       let(:right){ Factory.in(:x, [5]) }
 
-      it{ should eql(Factory.contradiction) }
+      it {
+        expect(subject).to eql(Factory.contradiction)
+      }
     end
 
   end

data/spec/nodes/nadic_bool/test_free_variables.rb

@@ -7,7 +7,9 @@ class Predicate
     context "on a complex attribute comparison" do
       let(:expr){ Factory.comp(:neq, :x => :y, :z => 2) }
 
-      it{ should eq([:x, :y, :z]) }
+      it {
+        expect(subject).to eq([:x, :y, :z])
+      }
     end
 
   end