alf-core 0.15.0 → 0.16.0

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

@@ -1,105 +0,0 @@
-require 'spec_helper'
-module Alf
-  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
-end

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

@@ -1,68 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/identifier/test_and_split.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  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){ 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/identifier/test_free_variables.rb

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

data/spec/unit/alf-predicate/nodes/identifier/test_name.rb

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

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

@@ -1,16 +0,0 @@
-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/qualified_identifier/test_and_split.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  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){ 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/qualified_identifier/test_free_variables.rb

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

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_name.rb

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

data/spec/unit/alf-predicate/nodes/qualified_identifier/test_qualifier.rb

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

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

@@ -1,59 +0,0 @@
-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 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
-end

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

@@ -1,36 +0,0 @@
-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("->(t){ (t.x == 2) && (t.y == 3) }")
-        end
-      end
-
-    end
-  end
-end