predicate 1.0.0

data/spec/factory/test_native.rb

@@ -0,0 +1,19 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'native' do
+    include Factory
+
+    subject{ native(proc) }
+
+    context 'with a proc' do
+      let(:proc){ ->{} }
+
+      it_should_behave_like "a predicate AST node"
+
+      it{ should be_a(Native) }
+
+      it{ should eql([:native, proc]) }
+    end
+
+  end
+end

data/spec/factory/test_neq.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'neq' do
+    let(:method){ :neq }
+    let(:node_class){ Neq }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end

data/spec/factory/test_not.rb

@@ -0,0 +1,13 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'not' do
+    include Factory
+
+    subject{ self.not(true) }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Not) }
+    it{ should eql([:not, tautology]) }
+
+  end
+end

data/spec/factory/test_or.rb

@@ -0,0 +1,13 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'or' do
+    include Factory
+
+    subject{ self.or(true, true) }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Or) }
+    it{ should eql([:or, tautology, tautology]) }
+
+  end
+end

data/spec/factory/test_qualified_identifier.rb

@@ -0,0 +1,15 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'qualified_identifier' do
+    include Factory
+
+    subject{ qualified_identifier(:t, :name) }
+
+    it_should_behave_like "a predicate AST node"
+
+    it{ should be_a(QualifiedIdentifier) }
+
+    it{ should eql([:qualified_identifier, :t, :name]) }
+
+  end
+end

data/spec/factory/test_tautology.rb

@@ -0,0 +1,12 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'tautology' do
+    include Factory
+
+    subject{ tautology }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Tautology) }
+
+  end
+end

data/spec/grammar/test_match.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+class Predicate
+  describe Grammar, 'match?' do
+
+    context "tautology" do
+      subject{ Grammar[:tautology] }
+
+      it 'matches a tautology' do
+        subject.should be_match([:tautology, true])
+      end
+      it 'does no match a wrong one' do
+        subject.should_not be_match([:tautology, false])
+      end
+    end
+
+    context "contradiction" do
+      subject{ Grammar[:contradiction] }
+
+      it 'matches a tautology' do
+        subject.should be_match([:contradiction, false])
+      end
+      it 'does no match a wrong one' do
+        subject.should_not be_match([:contradiction, true])
+      end
+    end
+
+    context "identifier" do
+      subject{ Grammar[:identifier] }
+
+      it 'matches a valid ast' do
+        subject.should be_match([:identifier, :id])
+      end
+
+      it 'does not match an invalid ast' do
+        subject.should_not be_match([:identifier, 12])
+      end
+    end
+
+    context "literal" do
+      subject{ Grammar[:literal] }
+
+      it 'matches valid ASTs' do
+        subject.should be_match([:literal, 12])
+        subject.should be_match([:literal, true])
+      end
+    end
+
+    context "in" do
+      subject{ Grammar[:in] }
+
+      it 'matches valid ASTs' do
+        subject.should be_match([:in, [:identifier, :x], [2, 3]])
+      end
+      it 'does not match invalid ASTs' do
+        subject.should_not be_match([:in, :x])
+      end
+    end
+
+    context "eq" do
+      subject{ Grammar[:eq] }
+
+      it 'matches valid ASTs' do
+        subject.should 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]])
+      end
+    end
+
+    context "neq" do
+      subject{ Grammar[:neq] }
+
+      it 'matches valid ASTs' do
+        subject.should 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]])
+      end
+    end
+
+    context "native" do
+      subject{ Grammar[:native] }
+
+      it 'matches valid ASTs' do
+        subject.should be_match([:native, lambda{}])
+      end
+      it 'does not match invalid ASTs' do
+        subject.should_not be_match([:native, 12])
+      end
+    end
+
+  end
+end

data/spec/grammar/test_sexpr.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+class Predicate
+  describe Grammar, "sexpr" do
+
+    subject{ Grammar.sexpr(expr) }
+
+    let(:contradiction){
+      [:contradiction, false]
+    }
+    let(:identifier){
+      [:identifier, :name]
+    }
+
+    before do
+      subject.should be_a(Sexpr)
+    end
+
+    describe "tautology" do
+      let(:expr){ [:tautology, true] }
+
+      it{ should be_a(Tautology) }
+    end
+
+    describe "contradiction" do
+      let(:expr){ [:contradiction, false] }
+
+      it{ should be_a(Contradiction) }
+    end
+
+    describe "identifier" do
+      let(:expr){ [:identifier, :name] }
+
+      it{ should be_a(Identifier) }
+    end
+
+    describe "and" do
+      let(:expr){ [:and, contradiction, contradiction] }
+
+      it{ should be_a(And) }
+    end
+
+    describe "or" do
+      let(:expr){ [:or, contradiction, contradiction] }
+
+      it{ should be_a(Or) }
+    end
+
+    describe "not" do
+      let(:expr){ [:not, contradiction] }
+
+      it{ should be_a(Not) }
+    end
+
+    describe "eq" do
+      let(:expr){ [:eq, identifier, identifier] }
+
+      it{ should be_a(Eq) }
+    end
+
+    describe "neq" do
+      let(:expr){ [:neq, identifier, identifier] }
+
+      it{ should be_a(Neq) }
+    end
+
+    describe "gt" do
+      let(:expr){ [:gt, identifier, identifier] }
+
+      it{ should be_a(Gt) }
+    end
+
+    describe "gte" do
+      let(:expr){ [:gte, identifier, identifier] }
+
+      it{ should be_a(Gte) }
+    end
+
+    describe "lt" do
+      let(:expr){ [:lt, identifier, identifier] }
+
+      it{ should be_a(Lt) }
+    end
+
+    describe "lte" do
+      let(:expr){ [:lte, identifier, identifier] }
+
+      it{ should be_a(Lte) }
+    end
+
+    describe "literal" do
+      let(:expr){ [:literal, 12] }
+
+      it{ should be_a(Literal) }
+    end
+
+    describe "native" do
+      let(:expr){ [:native, lambda{}] }
+
+      it{ should be_a(Native) }
+    end
+
+  end
+end

data/spec/nodes/and/test_and_split.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+class Predicate
+  describe And, "and_split" do
+
+    let(:tautology){ Factory.tautology  }
+
+    subject{ predicate.and_split(list) }
+
+    context 'when attributes on one side' do
+      let(:predicate){ Factory.eq(:x, 2) & Factory.eq(:y, 3) }
+
+      context 'when fully covered' do
+        let(:list){ [:x, :y] }
+
+        it{ should eq([predicate, tautology]) }
+      end
+
+      context 'when not covered at all' do
+        let(:list){ [:name] }
+
+        it{ should eq([tautology, predicate]) }
+      end
+
+      context 'when partially covered' do
+        let(:list){ [:x] }
+
+        it{ should eq([Factory.eq(:x, 2), Factory.eq(:y, 3)]) }
+      end
+    end
+
+    context 'when attributes on both sides' do
+      let(:predicate){ Factory.eq(:x, 2) & Factory.eq(:y, :z) }
+
+      context 'when fully covered' do
+        let(:list){ [:x, :y, :z] }
+
+        it{ should eq([predicate, tautology]) }
+      end
+
+      context 'when not covered at all' do
+        let(:list){ [:name] }
+
+        it{ should 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)]) }
+      end
+
+      context 'when partially covered but split-able (2)' do
+        let(:list){ [:y] }
+
+        it{ should 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]) }
+      end
+    end
+
+  end
+end

data/spec/nodes/dyadic_comp/test_and_split.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+class Predicate
+  describe DyadicComp, "and_split" do
+
+    let(:predicate){ Factory.eq(:id, 2) }
+    let(:tautology){ Factory.tautology  }
+
+    subject{ predicate.and_split(list) }
+
+    context 'when included' do
+      let(:list){ [:id, :name] }
+
+      it{ should eq([predicate, tautology]) }
+    end
+
+    context 'when not include' do
+      let(:list){ [:name] }
+
+      it{ should eq([tautology, predicate]) }
+    end
+
+    context 'with attributes on both sides' do
+      let(:predicate){ Factory.eq(:x, :y) }
+
+      context 'when full at left' do
+        let(:list){ [:x, :y] }
+      
+        it{ should eq([predicate, tautology]) }
+      end
+      
+      context 'none at left' do
+        let(:list){ [] }
+      
+        it{ should eq([tautology, predicate]) }
+      end
+
+      context 'mix' do
+        let(:list){ [:y] }
+
+        it{ should eq([predicate, tautology]) }
+      end
+    end
+
+  end
+end

data/spec/nodes/identifier/test_and_split.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+class Predicate
+  describe Identifier, "and_split" do
+
+    let(:predicate){ Factory.identifier(:id) }
+    let(:tautology){ Factory.tautology    }
+
+    subject{ predicate.and_split(list) }
+
+    context 'when included' do
+      let(:list){ [:id, :name] }
+
+      it{ should eq([predicate, tautology]) }
+    end
+
+    context 'when not include' do
+      let(:list){ [:name] }
+
+      it{ should eq([tautology, predicate]) }
+    end
+
+  end
+end

data/spec/nodes/identifier/test_free_variables.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+class Predicate
+  describe Identifier, "free_variables" do
+
+    let(:expr){ Factory.identifier(:id) }
+
+    subject{ expr.free_variables }
+
+    it{ should eq([:id]) }
+
+  end
+end

data/spec/nodes/identifier/test_name.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+class Predicate
+  describe Identifier, "name" do
+
+    let(:expr){ Factory.identifier(:id) }
+
+    subject{ expr.name }
+
+    it{ should eq(:id) }
+
+  end
+end

data/spec/nodes/nadic_bool/test_free_variables.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+class Predicate
+  describe NadicBool, "free_variables" do
+
+    subject{ expr.free_variables }
+
+    context "on a complex attribute comparison" do
+      let(:expr){ Factory.comp(:neq, :x => :y, :z => 2) }
+
+      it{ should eq([:x, :y, :z]) }
+    end
+
+  end
+end

data/spec/nodes/qualified_identifier/test_and_split.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+class Predicate
+  describe QualifiedIdentifier, "and_split" do
+
+    let(:predicate){ Factory.qualified_identifier(:t, :id) }
+    let(:tautology){ Factory.tautology    }
+
+    subject{ predicate.and_split(list) }
+
+    context 'when included' do
+      let(:list){ [:id, :name] }
+
+      it{ should eq([predicate, tautology]) }
+    end
+
+    context 'when not include' do
+      let(:list){ [:name] }
+
+      it{ should eq([tautology, predicate]) }
+    end
+
+  end
+end

data/spec/nodes/qualified_identifier/test_free_variables.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+class Predicate
+  describe QualifiedIdentifier, "free_variables" do
+
+    let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+    subject{ expr.free_variables }
+
+    it{ should eq([:id]) }
+
+  end
+end

data/spec/nodes/qualified_identifier/test_name.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+class Predicate
+  describe QualifiedIdentifier, "name" do
+
+    let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+    subject{ expr.name }
+
+    it{ should eq(:id) }
+
+  end
+end

data/spec/nodes/qualified_identifier/test_qualifier.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+class Predicate
+  describe QualifiedIdentifier, "qualified" do
+
+    let(:expr){ Factory.qualified_identifier(:t, :id) }
+
+    subject{ expr.qualifier }
+
+    it{ should eq(:t) }
+
+  end
+end

data/spec/predicate/test_and_split.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "and_split" do
+
+    let(:p){ Predicate }
+    subject{ pred.and_split([:x]) }
+
+    context "on tautology" do
+      let(:pred){ p.tautology }
+
+      it{ should eq([p.tautology, p.tautology]) }
+    end
+
+    context "on contradiction" do
+      let(:pred){ p.contradiction }
+
+      it{ should eq([p.tautology, pred]) }
+    end
+
+    context "on identifier (included)" do
+      let(:pred){ p.identifier(:x) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on identifier (excluded)" do
+      let(:pred){ p.identifier(:y) }
+
+      it{ should eq([ p.tautology, pred ]) }
+    end
+
+    context "on not (included)" do
+      let(:pred){ p.not(:x) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on not (excluded)" do
+      let(:pred){ p.not(:y) }
+
+      it{ should eq([ p.tautology, pred ]) }
+    end
+
+    context "on eq (included)" do
+      let(:pred){ p.eq(:x, 2) }
+
+      it{ should eq([ pred, p.tautology ]) }
+    end
+
+    context "on eq (excluded)" do
+      let(:pred){ p.eq(:y, 2) }
+
+      it{ should eq([ p.tautology, pred ]) }
+    end
+
+  end
+end

data/spec/predicate/test_bool_and.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "&" do
+
+    let(:left) { Predicate.coerce(x: 2) }
+
+    subject{ left & right }
+
+    before do
+      subject.should be_a(Predicate)
+    end
+
+    context 'with itself' do
+      let(:right){ left }
+
+      it{ should be(left) }
+    end
+
+    context 'with the same expression' do
+      let(:right){ Predicate.coerce(x: 2) }
+
+      it{ should be(left) }
+    end
+
+    context 'with another predicate' do
+      let(:right){ Predicate.coerce(y: 3) }
+
+      it 'should be a expected' do
+        subject.to_ruby_code.should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }")
+      end
+    end
+
+  end
+end

data/spec/predicate/test_bool_not.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+class Predicate
+  describe Predicate, "!" do
+
+    subject{ !pred }
+
+    context "on tautology" do
+      let(:pred){ Predicate.tautology }
+
+      it{ should eq(Predicate.contradiction) }
+    end
+
+    context "on contradiction" do
+      let(:pred){ Predicate.contradiction }
+
+      it{ should eq(Predicate.tautology) }
+    end
+
+    context "on not" do
+      let(:pred){ Predicate.not(:x) }
+
+      it{ should eq(Predicate.identifier(:x)) }
+    end
+
+    context "on comp" do
+      let(:pred){ Predicate.comp(:eq, :x => 2) }
+
+      it{ should eq(Predicate.comp(:neq, :x => 2)) }
+    end
+
+    context "on eq" do
+      let(:pred){ Predicate.eq(:x => 2) }
+
+      it{ should eq(Predicate.neq(:x => 2)) }
+    end
+
+    context "on neq" do
+      let(:pred){ Predicate.neq(:x => 2) }
+
+      it{ should eq(Predicate.eq(:x => 2)) }
+    end
+
+    context "on lt" do
+      let(:pred){ Predicate.lt(:x => 2) }
+
+      it{ should eq(Predicate.gte(:x => 2)) }
+    end
+
+    context "on lte" do
+      let(:pred){ Predicate.lte(:x => 2) }
+
+      it{ should eq(Predicate.gt(:x => 2)) }
+    end
+
+    context "on gt" do
+      let(:pred){ Predicate.gt(:x => 2) }
+
+      it{ should eq(Predicate.lte(:x => 2)) }
+    end
+
+    context "on gte" do
+      let(:pred){ Predicate.gte(:x => 2) }
+
+      it{ should eq(Predicate.lt(:x => 2)) }
+    end
+
+  end
+end