alf-core 0.13.0

data/spec/unit/alf-predicate/grammar/test_parse.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Grammar, 'parse' do
+
+      let(:source){ "x < 2" }
+
+      subject{ Grammar.parse(source) }
+
+      it{ should be_a(Sexpr) }
+      it{ should be_a(Native) }
+
+      specify{
+        subject.to_ruby_code.should eq("x < 2")
+      }
+
+      specify{
+        subject.to_proc.to_ruby_literal.should eq("lambda{ x < 2 }")
+      }
+      
+    end
+  end
+end

data/spec/unit/alf-predicate/grammar/test_sexpr.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Grammar, "sexpr" do
+
+      subject{ Grammar.sexpr(expr) }
+
+      let(:contradiction){
+        [:contradiction, false]
+      }
+      let(:var_ref){
+        [:var_ref, :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 "var_ref" do
+        let(:expr){ [:var_ref, :name] }
+
+        it{ should be_a(VarRef) }
+      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, var_ref, var_ref] }
+
+        it{ should be_a(Eq) }
+      end
+
+      describe "neq" do
+        let(:expr){ [:neq, var_ref, var_ref] }
+
+        it{ should be_a(Neq) }
+      end
+
+      describe "gt" do
+        let(:expr){ [:gt, var_ref, var_ref] }
+
+        it{ should be_a(Gt) }
+      end
+
+      describe "gte" do
+        let(:expr){ [:gte, var_ref, var_ref] }
+
+        it{ should be_a(Gte) }
+      end
+
+      describe "lt" do
+        let(:expr){ [:lt, var_ref, var_ref] }
+
+        it{ should be_a(Lt) }
+      end
+
+      describe "lte" do
+        let(:expr){ [:lte, var_ref, var_ref] }
+
+        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
+end

data/spec/unit/alf-predicate/nodes/and/test_and_split.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+module Alf
+  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){ AttrList[:x, :y] }
+
+          it{ should eq([predicate, tautology]) }
+        end
+
+        context 'when not covered at all' do
+          let(:list){ AttrList[:name] }
+
+          it{ should eq([tautology, predicate]) }
+        end
+
+        context 'when partially covered' do
+          let(:list){ AttrList[: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){ AttrList[:x, :y, :z] }
+
+          it{ should eq([predicate, tautology]) }
+        end
+
+        context 'when not covered at all' do
+          let(:list){ AttrList[:name] }
+
+          it{ should eq([tautology, predicate]) }
+        end
+
+        context 'when partially covered but split-able' do
+          let(:list){ AttrList[:x] }
+
+          it{ should eq([Factory.eq(:x, 2), Factory.eq(:y, :z)]) }
+        end
+
+        context 'when partially covered but split-able (2)' do
+          let(:list){ AttrList[:y] }
+
+          it{ should eq([Factory.eq(:y, :z), Factory.eq(:x, 2)]) }
+        end
+
+        context 'when partially covered but not split-able' do
+          let(:list){ AttrList[:x, :y] }
+
+          it{ should eq([predicate, tautology]) }
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/dyadic_comp/test_and_split.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+module Alf
+  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){ AttrList[:id, :name] }
+
+        it{ should eq([predicate, tautology]) }
+      end
+
+      context 'when not include' do
+        let(:list){ AttrList[: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){ AttrList[:x, :y] }
+        
+          it{ should eq([predicate, tautology]) }
+        end
+        
+        context 'none at left' do
+          let(:list){ AttrList[] }
+        
+          it{ should eq([tautology, predicate]) }
+        end
+
+        context 'mix' do
+          let(:list){ AttrList[:y] }
+
+          it{ should eq([predicate, tautology]) }
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/nadic_bool/test_free_variables.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  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(AttrList[:x, :y, :z]) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/var_ref/test_and_split.rb

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

data/spec/unit/alf-predicate/nodes/var_ref/test_free_variables.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe VarRef, "free_variables" do
+
+      let(:expr){ Factory.var_ref(:id) }
+
+      subject{ expr.free_variables }
+
+      it{ should eq(AttrList[:id]) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/nodes/var_ref/test_var_name.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe VarRef, "var_name" do
+
+      let(:expr){ Factory.var_ref(:id) }
+
+      subject{ expr.var_name }
+
+      it{ should eq(:id) }
+
+    end
+  end
+end

data/spec/unit/alf-predicate/predicate/test_and_split.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "and_split" do
+
+      let(:p){ Predicate }
+      subject{ pred.and_split(AttrList[: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 var_ref (included)" do
+        let(:pred){ p.var_ref(:x) }
+
+        it{ should eq([ pred, p.tautology ]) }
+      end
+
+      context "on var_ref (excluded)" do
+        let(:pred){ p.var_ref(: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
+end

data/spec/unit/alf-predicate/predicate/test_bool_and.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  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("(self.x == 2) && (self.y == 3)")
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-predicate/predicate/test_bool_not.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+module Alf
+  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.var_ref(: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
+end