alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-algebra/operator/rename/test_type_check.rb

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Rename, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          rename(suppliers, name: :sname)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when invalid renaming' do
+        let(:op){ 
+          rename(suppliers, foo: :bar)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when name clash' do
+        let(:op){ 
+          rename(suppliers, name: :sid)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `sid`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/restrict/test_type_check.rb

@@ -0,0 +1,46 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Restrict, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          restrict(suppliers, city: 'London')
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when no such attribute' do
+        let(:op){ 
+          restrict(suppliers, foo: 'London')
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when no such attribute (complex expression)' do
+        let(:pred){
+          pred = Predicate.eq(city: "London")
+          pred = pred | (Predicate.neq(foo: "Paris") & Predicate.neq(bar: "Paris"))
+        }
+        let(:op){ 
+          restrict(suppliers, pred)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/shared/test_to_cog.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Operator, "to_cog" do
+
+      subject{ op.to_cog }
+
+      context 'on nullary' do
+        let(:op){
+          a_lispy.generator(100)
+        }
+
+        it{ should be_a(Engine::Cog) }
+      end
+
+      context 'on unary' do
+        let(:op){
+          a_lispy.restrict(an_operand, ->{ true })
+        }
+
+        it{ should be_a(Engine::Cog) }
+      end
+
+      context 'on binary' do
+        let(:op){
+          a_lispy.union(an_operand, an_operand)
+        }
+
+        it{ should be_a(Engine::Cog) }
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/sort/test_type_check.rb

@@ -0,0 +1,30 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Sort, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          sort(suppliers, [:name, :asc])
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when no such attribute' do
+        let(:op){ 
+          sort(suppliers, [:foo, :asc])
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/summarize/test_type_check.rb

@@ -0,0 +1,42 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Summarize, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          summarize(supplies, [:sid], :sum => sum{ qty })
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when unknown by' do
+        let(:op){ 
+          summarize(supplies, [:foo], :sum => sum{ qty })
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attribute `foo`/)
+        end
+      end
+
+      context 'when name clash' do
+        let(:op){ 
+          summarize(supplies, [:sid], :qty => sum{ qty })
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `qty`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/test_hash_and_equal.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Operator, "hash and ==" do
+
+      let(:foo){
+        Operand::Named.new(:foo)
+      }
+
+      let(:bar){
+        Operand::Named.new(:bar)
+      }
+
+      let(:op1){
+        a_lispy.restrict(foo, x: 12)
+      }
+
+      context '==' do
+
+        it 'recognizes same operands' do
+          op1.should eq(op1)
+          op1.should eq(a_lispy.restrict(foo, x: 12))
+        end
+
+        it 'distinguises other operands' do
+          op1.should_not eq(nil)
+          op1.should_not eq(a_lispy.restrict(bar, x: 12))
+          op1.should_not eq(a_lispy.restrict(foo, x: 13))
+        end
+      end
+
+      context 'hash' do
+
+        it 'it the same on same operands' do
+          op1.hash.should eq(a_lispy.restrict(foo, x: 12).hash)
+        end
+      end
+
+      context 'using named operands as hash keys' do
+
+        let(:h){
+          { op1 => 1,
+            a_lispy.restrict(bar, x: 12) => 2 }
+        }
+
+        it 'should lead to expected hash' do
+          h.size.should eq(2)
+        end
+
+        it 'should behave as expected' do
+          h[op1].should eq(1)
+          h[a_lispy.restrict(bar, x: 12)].should eq(2)
+          h[a_lispy.restrict(foo, x: 12)].should eq(1)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/ungroup/test_type_check.rb

@@ -0,0 +1,44 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Ungroup, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          ungroup(group(suppliers, [:status, :city], :extra), :extra)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when not a grouped attribute' do
+        let(:op){ 
+          ungroup(suppliers, :sid)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /not a relation-valued attribute `sid`/)
+        end
+      end
+
+      context 'when name clash resulting' do
+        let(:op){ 
+          inside = group(suppliers, [:status, :city], :extra)
+          inside = rename(inside, :sid => :city)
+          ungroup(inside, :extra)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `city`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/union/test_type_check.rb

@@ -0,0 +1,30 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Union, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          union(suppliers, suppliers)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when heading mismatch' do
+        let(:op){ 
+          union(suppliers, supplies)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /heading mismatch/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/unwrap/test_type_check.rb

@@ -0,0 +1,44 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Unwrap, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          unwrap(wrap(suppliers, [:status, :city], :extra), :extra)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when not a grouped attribute' do
+        let(:op){ 
+          unwrap(suppliers, :sid)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /not a tuple-valued attribute `sid`/)
+        end
+      end
+
+      context 'when name clash resulting' do
+        let(:op){ 
+          inside = wrap(suppliers, [:status, :city], :extra)
+          inside = rename(inside, :sid => :city)
+          unwrap(inside, :extra)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `city`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/wrap/test_type_check.rb

@@ -0,0 +1,50 @@
+require 'type_check_helper'
+module Alf
+  module Algebra
+    describe Wrap, 'type_check' do
+
+      subject{ op.type_check }
+
+      context 'when ok' do
+        let(:op){ 
+          wrap(suppliers, [:status, :city], :extra)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when ok (allowed overriding)' do
+        let(:op){ 
+          wrap(suppliers, [:status, :city], :status)
+        }
+
+        it{ should eq(op.heading) }
+      end
+
+      context 'when no such attributes' do
+        let(:op){ 
+          wrap(suppliers, [:status, :foo, :bar], :extra)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
+        end
+      end
+
+      context 'when diasllowed overriding' do
+        let(:op){ 
+          wrap(suppliers, [:status, :city], :name)
+        }
+
+        it 'should raise an error' do
+          lambda{
+            subject
+          }.should raise_error(TypeCheckError, /cannot override `name`/)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/alf-algebra/support/signature/test_to_lispy.rb

@@ -10,7 +10,7 @@ module Alf
 
         describe "on an empty signature" do
           let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("(generator)") }
+          it{ should eq("generator()") }
         end
 
         describe "on an option-only signature" do
@@ -19,7 +19,7 @@ module Alf
               s.option :allbut, Boolean
             end
           }
-          it{ should eq("(generator {allbut: Boolean})") }
+          it{ should eq("generator({allbut: Boolean})") }
         end
 
       end # nullary signature
@@ -29,7 +29,7 @@ module Alf
 
         describe "on an empty signature" do
           let(:signature){ Signature.new(clazz){|s|} }
-          it{ should eq("(coerce operand)") }
+          it{ should eq("coerce(operand)") }
         end
 
         describe "on an option-only signature" do
@@ -38,7 +38,7 @@ module Alf
               s.option :allbut, Boolean
             end
           }
-          it{ should eq("(coerce operand, {allbut: Boolean})") }
+          it{ should eq("coerce(operand, {allbut: Boolean})") }
         end
 
         describe "on an option-only signature with multiple options" do
@@ -48,7 +48,7 @@ module Alf
               s.option :newname, AttrName
             end
           }
-          it{ should eq("(coerce operand, {allbut: Boolean, newname: AttrName})") }
+          it{ should eq("coerce(operand, {allbut: Boolean, newname: AttrName})") }
         end
 
         describe "on a signature with one argument only" do
@@ -57,7 +57,7 @@ module Alf
               s.argument :by, AttrList
             end
           }
-          it{ should eq("(coerce operand, by:AttrList)") }
+          it{ should eq("coerce(operand, by:AttrList)") }
         end
 
         describe "on a signature with multiple arguments" do
@@ -67,7 +67,7 @@ module Alf
               s.argument :order, Ordering
             end
           }
-          it{ should eq("(coerce operand, by:AttrList, order:Ordering)") }
+          it{ should eq("coerce(operand, by:AttrList, order:Ordering)") }
         end
 
         describe "on a full signature" do
@@ -78,7 +78,7 @@ module Alf
               s.option :allbut, Boolean
             end
           }
-          it{ should eq("(coerce operand, by:AttrList, order:Ordering, {allbut: Boolean})") }
+          it{ should eq("coerce(operand, by:AttrList, order:Ordering, {allbut: Boolean})") }
         end
 
       end
@@ -92,7 +92,22 @@ module Alf
               s.option :allbut, Boolean
             end
           }
-          it{ should eq("(join left, right, {allbut: Boolean})") }
+          it{ should eq("join(left, right, {allbut: Boolean})") }
+        end
+
+      end
+
+      describe "on a operator having standard argument classes" do
+        let(:clazz){ Frame }
+
+        describe "on an option-only signature" do
+          let(:signature){
+            Signature.new(clazz) do |s|
+              s.argument :index, Integer
+              s.option   :size, Integer
+            end
+          }
+          it{ should eq("frame(operand, index:Integer, {size: Integer})") }
         end
 
       end