alf-core 0.14.0 → 0.15.0

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

@@ -17,8 +17,8 @@ module Alf
         it{ should be_true }
       end
 
-      context "var_ref" do
-        subject{ Predicate.var_ref(:x) }
+      context "identifier" do
+        subject{ Predicate.identifier(:x) }
 
         it{ should be_false }
       end

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

@@ -11,61 +11,61 @@ module Alf
       context "tautology" do
         subject{ Predicate.tautology }
 
-        specify{ subject.to_ruby_code.should eq("true") }
+        specify{ subject.to_ruby_code.should eq("->(t){ true }") }
       end
 
       context "contradiction" do
         subject{ Predicate.contradiction }
 
-        specify{ subject.to_ruby_code.should eq("false") }
+        specify{ subject.to_ruby_code.should eq("->(t){ false }") }
       end
 
-      context "var_ref" do
-        subject{ Predicate.var_ref(:x) }
+      context "identifier" do
+        subject{ Predicate.identifier(:x) }
 
-        specify{ subject.to_ruby_code.should eq("self.x") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x }") }
       end
 
       context "eq" do
         subject{ Predicate.eq(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x == 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x == 2 }") }
       end
 
       context "neq" do
         subject{ Predicate.neq(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x != 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x != 2 }") }
       end
 
       context "lt" do
         subject{ Predicate.lt(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x < 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x < 2 }") }
       end
 
       context "lte" do
         subject{ Predicate.lte(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x <= 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x <= 2 }") }
       end
 
       context "gt" do
         subject{ Predicate.gt(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x > 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x > 2 }") }
       end
 
       context "gte" do
         subject{ Predicate.gte(:x, 2) }
 
-        specify{ subject.to_ruby_code.should eq("self.x >= 2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ t.x >= 2 }") }
       end
 
       context "literal" do
         subject{ Predicate.literal(2) }
 
-        specify{ subject.to_ruby_code.should eq("2") }
+        specify{ subject.to_ruby_code.should eq("->(t){ 2 }") }
       end
 
       context "native" do

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  class Predicate
+    describe Predicate, "qualify" do
+
+      let(:p){ Predicate }
+
+      subject{ predicate.qualify(qualifier) }
+
+      let(:qualifier) { {:x => :t} }
+
+      context 'on a full AST predicate' do
+        let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
+
+        it{ should eq(p.in(Factory.qualified_identifier(:t, :x), [2]) & p.eq(:y, 3)) }
+
+        specify "it should tag expressions correctly" do
+          subject.expr.should be_a(Sexpr)
+          subject.expr.should be_a(Expr)
+          subject.expr.should be_a(And)
+        end
+      end
+
+      context 'on a predicate that contains natives' do
+        let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
+
+        it 'raises an error' do
+          lambda{
+            subject
+          }.should raise_error(NotSupportedError)
+        end
+      end
+
+    end
+  end
+end

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

@@ -6,30 +6,73 @@ module Alf
       let(:p){ Predicate }
 
       subject{ predicate.rename(renaming) }
-      let(:renaming) { Renaming[:x => :z] }
 
-      context 'on a full AST predicate' do
-        let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
+      context 'on a pure Renaming' do
+        let(:renaming) { Renaming[:x => :z] }
 
-        it{ should eq(p.in(:z, [2]) & p.eq(:y, 3)) }
+        context 'on a full AST predicate' do
+          let(:predicate){ p.in(:x, [2]) & p.eq(:y, 3) }
 
-        specify "it should tag expressions correctly" do
-          subject.expr.should be_a(Sexpr)
-          subject.expr.should be_a(Expr)
-          subject.expr.should be_a(And)
+          it{ should eq(p.in(:z, [2]) & p.eq(:y, 3)) }
+
+          specify "it should tag expressions correctly" do
+            subject.expr.should be_a(Sexpr)
+            subject.expr.should be_a(Expr)
+            subject.expr.should be_a(And)
+          end
+        end
+
+        context 'on a predicate that contains natives' do
+          let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
+
+          it 'raises an error' do
+            lambda{
+              subject
+            }.should raise_error(NotSupportedError)
+          end
+        end
+
+        context 'on a predicate that contains qualified identifiers' do
+          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 3) }
+
+          it 'renames correctly' do
+            subject.should eq(p.eq(Factory.qualified_identifier(:t, :z), 3))
+          end
+        end
+      end
+
+      context 'when the renamer is a Proc returning identifiers' do
+        let(:renaming){ ->(a){ Grammar.sexpr([:identifier, :y]) } }
+
+        context "on an identifier" do
+          let(:predicate){ p.eq(:x, 2) }
+
+          it{ should eq(p.eq(:y, 2)) }
+        end
+
+        context "on a qualifier identifier" do
+          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
+
+          it{ should eq(p.eq(:y, 2)) }
         end
       end
 
-      context 'on a predicate that contains natives' do
-        let(:predicate){ p.in(:x, [2]) & p.native(lambda{}) }
+      context 'when the renamer is a Proc returning qualified identifiers' do
+        let(:renaming){ ->(a){ Grammar.sexpr([:qualified_identifier, :t, :y]) } }
 
-        it 'raises an error' do
-          lambda{
-            subject
-          }.should raise_error(NotSupportedError)
+        context 'on an identifier' do
+          let(:predicate){ p.eq(:x, 2) }
+
+          it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
+        end
+
+        context 'on a qualified' do
+          let(:predicate){ p.eq(Factory.qualified_identifier(:t, :x), 2) }
+
+          it{ should eq(p.eq(Factory.qualified_identifier(:t, :y), 2)) }
         end
       end
-      
+
     end
   end
 end

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

@@ -17,8 +17,8 @@ module Alf
         it{ should be_false }
       end
 
-      context "var_ref" do
-        subject{ Predicate.var_ref(:x) }
+      context "identifier" do
+        subject{ Predicate.identifier(:x) }
 
         it{ should be_false }
       end

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

@@ -8,9 +8,15 @@ module Alf
       describe "on a comp(:eq)" do
         let(:p){ Predicate.coerce(:x => 2) }
 
-        it{ should eq("self.x == 2") }
+        it{ should eq("->(t){ t.x == 2 }") }
       end
-      
+
+      describe "with qualified identifiers" do
+        let(:p){ Predicate.eq(Factory.qualified_identifier(:t, :y), 2) }
+
+        it{ should eq("->(t){ t.y == 2 }") }
+      end
+
     end
   end
 end

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

@@ -8,7 +8,7 @@ module Alf
       describe "on a comp(:eq)" do
         let(:p){ Predicate.coerce(:x => 2) }
 
-        it{ should eq("lambda{ self.x == 2 }") }
+        it{ should eq("->(t){ t.x == 2 }") }
       end
       
     end

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

@@ -5,15 +5,8 @@ shared_examples_for "a predicate" do
   let(:x){ 12 }
   let(:y){ 13 }
 
-  it 'can be compiled to valid ruby code' do
-    code = subject.to_ruby_code
-    got  = Kernel::eval code, binding
-    msg  = "Expected `#{code}` to return truth value (#{subject.expr.inspect})"
-    [ TrueClass, FalseClass ].should include(got.class), msg
-  end
-
   it 'provides a proc for easy evaluation' do
-    got = instance_exec(&subject.to_proc)
+    got = subject.to_proc.call(Tuple(x: 12, y: 13))
     [ TrueClass, FalseClass ].should include(got.class)
   end
 
@@ -68,6 +61,12 @@ module Alf
     it_should_behave_like "a predicate"
   end
 
+  describe "Predicate.among" do
+    subject{ Predicate.among(:x, [2, 3]) }
+
+    it_should_behave_like "a predicate"
+  end
+
   describe "Predicate.eq" do
     subject{ Predicate.eq(:x, 2) }
 

data/spec/unit/alf-relation/relation/class/test_dum.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+module Alf
+  describe Relation, '.dum' do
+
+    let(:type){ Relation[name: String, status: Integer] }
+
+    subject{ type.dum }
+
+    it 'returns a Relation' do
+      subject.should be_a(type)
+      subject.should be_a(Relation)
+    end
+
+    it 'is empty' do
+      subject.should be_empty
+    end
+
+  end
+end

data/spec/unit/alf-relation/relation/test_heading.rb

@@ -14,4 +14,4 @@ module Alf
     it{ should eq(Heading(:max => Numeric, :name => String)) }
 
   end
-end
+end

data/spec/unit/alf-relation/relation/test_keys.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  describe "Relation#keys" do
+
+    let(:rel){
+      Relation([
+        {:max => 2,   :name => "Jones"},
+        {:max => 7.3, :name => "Jones"},
+      ])
+    }
+
+    subject{ rel.keys }
+
+    it{ should eq(Keys[[:max, :name]]) }
+
+  end
+end

data/spec/unit/alf-relation/relation/test_relation.rb

@@ -68,7 +68,7 @@ module Alf
       it_should_behave_like "A value"
       specify{
         subject.cardinality.should == 1
-        subject.to_a.should == [Tuple::EMPTY]
+        subject.to_a.should == [{}]
         subject.should_not be_empty
       }
     end

data/spec/unit/alf-relation/relation/test_to_a.rb

@@ -6,22 +6,22 @@ module Alf
 
     specify "without an ordering key" do
       rel.to_a.sort{|k1,k2| k1[:sid] <=> k2[:sid]}.should eq([
-        Tuple(:sid => 'S1'),
-        Tuple(:sid => 'S2'),
-        Tuple(:sid => 'S3')
+        {:sid => 'S1'},
+        {:sid => 'S2'},
+        {:sid => 'S3'}
       ])
     end
 
     specify "with an ordering key" do
       rel.to_a([:sid]).should eq([
-        Tuple(:sid => 'S1'),
-        Tuple(:sid => 'S2'),
-        Tuple(:sid => 'S3')
+        {:sid => 'S1'},
+        {:sid => 'S2'},
+        {:sid => 'S3'}
       ])
       rel.to_a([[:sid, :desc]]).should eq([
-        Tuple(:sid => 'S3'),
-        Tuple(:sid => 'S2'),
-        Tuple(:sid => 'S1')
+        {:sid => 'S3'},
+        {:sid => 'S2'},
+        {:sid => 'S1'}
       ])
     end
 
@@ -30,7 +30,7 @@ module Alf
     end
 
     specify "ON DEE" do
-      Relation::DEE.to_a.should eq([Tuple::EMPTY])
+      Relation::DEE.to_a.should eq([{}])
     end
 
   end

data/spec/unit/alf-relvar/base/test_oo_lang.rb

@@ -6,22 +6,38 @@ module Alf
       let(:expr){ Algebra::Operand::Named.new(:suppliers, self) }
       let(:rv)  { Base.new(expr)                                }
 
-      subject{ rv.project([:sid]) }
+      shared_examples_for "the result of a query operator" do
+        it 'is a relation variable' do
+          subject.should be_a(Relvar)
+        end
 
-      it 'is a relation variable' do
-        subject.should be_a(Relvar)
-      end
+        it 'is a virtual relation variable' do
+          subject.should be_a(Relvar::Virtual)
+        end
 
-      it 'is a virtual relation variable' do
-        subject.should be_a(Relvar::Virtual)
+        it 'should have the initial expression as projection operand' do
+          subject.expr.operand.should be(expr)
+        end
       end
 
-      it 'should have a projection expression' do
-        subject.expr.should be_a(Algebra::Project)
+      context 'on project' do
+        subject{ rv.project([:sid]) }
+
+        it_should_behave_like "the result of a query operator"
+
+        it 'should have a projection expression' do
+          subject.expr.should be_a(Algebra::Project)
+        end
       end
 
-      it 'should have the base relvar as projection operand' do
-        subject.expr.operand.should be(rv)
+      context 'on allbut' do
+        subject{ rv.allbut([:sid]) }
+
+        it_should_behave_like "the result of a query operator"
+
+        it 'should have an allbut expression' do
+          subject.expr.should be_a(Algebra::Allbut)
+        end
       end
 
     end

data/spec/unit/alf-relvar/base/test_to_cog.rb

@@ -10,11 +10,11 @@ module Alf
         @seen = args
       end
 
-      subject{ rv.to_cog }
+      subject{ rv.to_cog(12) }
 
       it 'delegates to the connection' do
         subject
-        @seen.should eq([:suppliers, rv])
+        @seen.should eq([12, expr])
       end
 
     end

data/spec/unit/alf-relvar/read_only/test_to_relation.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  module Relvar
+    describe ReadOnly, "to_relation" do
+
+      let(:value){ Relation(id: 1)     }
+      let(:rv)   { ReadOnly.new(value) }
+
+      subject{ rv.to_relation }
+
+      it 'is as expected' do
+        subject.should be(value)
+      end
+
+    end
+  end
+end