predicate 2.7.1 → 2.9.0

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

data/spec/nodes/or/test_and_split.rb

@@ -12,13 +12,17 @@ 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 fully disjoint' do
         let(:list){ [:z] }
 
-        it{ should eq([tautology, predicate]) }
+        it {
+          expect(subject).to eq([tautology, predicate])
+        }
       end
 
     end

data/spec/nodes/qualified_identifier/test_and_split.rb

@@ -10,13 +10,17 @@ class Predicate
     context 'when included' do
       let(:list){ [:"t.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/qualified_identifier/test_free_variables.rb

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

data/spec/nodes/qualified_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/qualified_identifier/test_qualifier.rb

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

data/spec/predicate/test_and_split.rb

@@ -8,97 +8,129 @@ class Predicate
     context "on tautology" do
       let(:pred){ p.tautology }
 
-      it{ should eq([p.tautology, p.tautology]) }
+      it {
+        expect(subject).to eq([p.tautology, p.tautology])
+      }
     end
 
     context "on contradiction" do
       let(:pred){ p.contradiction }
 
-      it{ should eq([p.tautology, pred]) }
+      it {
+        expect(subject).to eq([p.tautology, pred])
+      }
     end
 
     context "on identifier (included)" do
       let(:pred){ p.identifier(:x) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on identifier (excluded)" do
       let(:pred){ p.identifier(:y) }
 
-      it{ should eq([ p.tautology, pred ]) }
+      it {
+        expect(subject).to eq([ p.tautology, pred ])
+      }
     end
 
     context "on not (included)" do
       let(:pred){ p.not(:x) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on not (excluded)" do
       let(:pred){ p.not(:y) }
 
-      it{ should eq([ p.tautology, pred ]) }
+      it {
+        expect(subject).to eq([ p.tautology, pred ])
+      }
     end
 
     context "on eq (included)" do
       let(:pred){ p.eq(:x, 2) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on eq (excluded)" do
       let(:pred){ p.eq(:y, 2) }
 
-      it{ should eq([ p.tautology, pred ]) }
+      it {
+        expect(subject).to eq([ p.tautology, pred ])
+      }
     end
 
     context "on eq with placeholder" do
       let(:pred){ p.eq(:x, p.placeholder) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on in with placeholder" do
       let(:pred){ p.in(:x, p.placeholder) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on match (included)" do
       let(:pred){ p.match(:x, "London") }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on match (excluded)" do
       let(:pred){ p.match(:y, "London") }
 
-      it{ should eq([ p.tautology, pred ]) }
+      it {
+        expect(subject).to eq([ p.tautology, pred ])
+      }
     end
 
     context "on match (included on right)" do
       let(:pred){ p.match(:y, :x) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on intersect" do
       let(:pred){ p.intersect(:x, [1, 2]) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on subset" do
       let(:pred){ p.subset(:x, [1, 2]) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
     context "on superset" do
       let(:pred){ p.superset(:x, [1, 2]) }
 
-      it{ should eq([ pred, p.tautology ]) }
+      it {
+        expect(subject).to eq([ pred, p.tautology ])
+      }
     end
 
   end

data/spec/predicate/test_assert!.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "assert!" do
+
+    describe "eq" do
+      let(:predicate) {
+        Predicate.eq(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and returns 2' do
+          expect(subject).to eql(2)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 3 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected: 3\s+Actual: 2/)
+        end
+      end
+    end
+
+    describe "gt" do
+      let(:predicate) {
+        Predicate.gt(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 3 }
+        }
+        it 'works and returns 3' do
+          expect(subject).to eql(3)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected 2 to be > 2/)
+        end
+      end
+    end
+
+    describe "gte" do
+      let(:predicate) {
+        Predicate.gte(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and returns 2' do
+          expect(subject).to eql(2)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 1 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected 1 to be >= 2/)
+        end
+      end
+    end
+
+    describe "lt" do
+      let(:predicate) {
+        Predicate.lt(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 1 }
+        }
+        it 'works and returns 1' do
+          expect(subject).to eql(1)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected 2 to be < 2/)
+        end
+      end
+    end
+
+    describe "lte" do
+      let(:predicate) {
+        Predicate.lte(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and returns 2' do
+          expect(subject).to eql(2)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 3 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected 3 to be <= 2/)
+        end
+      end
+    end
+
+    describe "neq" do
+      let(:predicate) {
+        Predicate.neq(:x, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 3 }
+        }
+        it 'works and returns 3' do
+          expect(subject).to eql(3)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 2 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected 2 to not be equal to 2./)
+        end
+      end
+    end
+
+    describe "and" do
+      let(:predicate) {
+        Predicate.eq(:x, 2) & Predicate.eq(:y, 2)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 2, y: 2 }
+        }
+        it 'works and returns true' do
+          expect(subject).to eql(true)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 2, y: 3 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected: 3\n  Actual: 2/)
+        end
+      end
+    end
+
+    describe "empty" do
+      let(:predicate) {
+        Predicate.empty(:x)
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: [] }
+        }
+        it 'works and returns true' do
+          expect(subject).to eql([])
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: [2] }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected \[2\] to be empty/)
+        end
+      end
+    end
+
+    describe "in" do
+      let(:predicate) {
+        Predicate.in(:x, [2, 3, 4])
+      }
+
+      subject{
+        predicate.assert!(input)
+      }
+
+      context "when ok" do
+        let(:input){
+          { x: 3 }
+        }
+        it 'works and returns 3' do
+          expect(subject).to eql(3)
+        end
+      end
+
+      context "when ko" do
+        let(:input){
+          { x: 8 }
+        }
+        it 'works and throws' do
+          expect{
+            subject
+          }.to raise_error(Minitest::Assertion, /Expected \[2, 3, 4\] to include 8/)
+        end
+      end
+    end
+
+  end
+end
+

data/spec/predicate/test_attr_split.rb

@@ -8,73 +8,97 @@ 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({ nil => pred }) }
+      it {
+        expect(subject).to eq({ nil => pred })
+      }
     end
 
     context "on identifier" do
       let(:pred){ p.identifier(:x) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on not" do
       let(:pred){ p.not(:x) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on eq" do
       let(:pred){ p.eq(:x, 2) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on eq with placeholder" do
       let(:pred){ p.eq(:x, p.placeholder) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on in" do
       let(:pred){ p.in(:x, [2]) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on intersect" do
       let(:pred){ p.intersect(:x, [2]) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on subset" do
       let(:pred){ p.subset(:x, [2]) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on superset" do
       let(:pred){ p.superset(:x, [2]) }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on match" do
       let(:pred){ p.match(:x, "London") }
 
-      it{ should eq({ x: pred }) }
+      it {
+        expect(subject).to eq({ x: pred })
+      }
     end
 
     context "on match with two identifiers" do
       let(:pred){ p.match(:x, :y) }
 
-      it{ should eq({ nil => pred }) }
+      it {
+        expect(subject).to eq({ nil => pred })
+      }
     end
 
   end

data/spec/predicate/test_bool_and.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
 
     context 'with tautology' do