alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-algebra/operator/commons/test_resulting_type.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Operator, "resulting_type" do
-
-      subject{ operator.resulting_type }
-
-      context 'on an unary operator' do
-        let(:operator){
-          project(suppliers, [:sid, :name])
-        }
-
-        it 'returns the expected type' do
-          subject.should eq(Relation[sid: String, name: String])
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/commons/test_to_ascii_tree.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Operator, "to_ascii_tree" do
-
-      subject{ operator.to_ascii_tree }
-
-      context 'on an unary operator' do
-        let(:operator){
-          project(suppliers, [:sid, :name])
-        }
-
-        it 'returns the expected tree' do
-          subject.should eq("project(..., [:sid, :name])\n+-- suppliers\n")
-        end
-      end
-
-      context 'on an unary operator with options' do
-        let(:operator){
-          project(suppliers, [:sid, :name], allbut: true)
-        }
-
-        it 'returns the expected tree' do
-          subject.should eq("project(..., [:sid, :name], {:allbut => true})\n+-- suppliers\n")
-        end
-      end
-
-      context 'on an binary operator' do
-        let(:operator){
-          union(suppliers, parts)
-        }
-
-        it 'returns the expected tree' do
-          subject.should eq("union(...)\n+-- suppliers\n+-- parts\n")
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/commons/test_with_operands.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Operator, "with_operands" do
-
-      let(:operand_1) { an_operand.with_heading(:id => Integer).with_keys([:id])    }
-      let(:operand_2) { an_operand.with_heading(:name => String).with_keys([:name]) }
-
-      let(:operator) { a_lispy.project(operand_1, [:foo], :allbut => true) }
-
-      subject{ operator.with_operands(operand_2) }
-
-      it{ should be_a(Project) }
-
-      before do
-        operator.heading
-        operator.keys
-      end
-
-      it "replaces the operands but keeps params unchanged" do
-        subject.operands.first.should be(operand_2)
-        subject.attributes.should eq(AttrList[:foo])
-        subject.allbut.should be_true
-      end
-
-      it "keeps the original unchanged" do
-        operator.operands.first.should be(operand_1)
-        subject.attributes.should eq(AttrList[:foo])
-        subject.allbut.should be_true
-      end
-
-      it 'does not keep computed heading from the original' do
-        subject.heading.should eq(Heading.coerce(:name => String))
-      end
-
-      it 'does not keep computed keys from the original' do
-        subject.keys.should eq(Keys[ [:name] ])
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/compact/test_heading.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Compact, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:id => String, :name => String)
-      }
-
-      subject{ op.heading }
-
-      let(:op){ 
-        a_lispy.compact(operand)
-      }
-      let(:expected){
-        Heading[:id => String, :name => String]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/compact/test_keys.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Compact, 'keys' do
-
-      subject{ op.keys }
-
-      let(:op){ 
-        a_lispy.compact(operand)
-      }
-
-      context 'when the operand has a key' do
-        let(:operand){
-          an_operand.with_heading(:id => String, :name => String).
-                     with_keys([ :id ])
-        }
-        let(:expected){
-          Keys[ [ :id ] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-      context 'when the operand has no key' do
-        let(:operand){
-          an_operand.with_heading(:id => String, :name => String).
-                     with_keys()
-        }
-        let(:expected){
-          Keys[ [ :id, :name ] ]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/defaults/test_heading.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Defaults, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String)
-      }
-
-      subject{ op.heading }
-
-      context '--no-strict' do
-        let(:op){ 
-          a_lispy.defaults(operand, {:id => lambda{12}})
-        }
-        let(:expected){
-          Heading[:id => String, :name => String]
-        }
-
-        it {
-          pending "type inference on expressions not implemented" do
-            should eq(expected)
-          end
-        }
-
-        it{ should eq(Heading[:id => Object, :name => String]) }
-      end
-
-      context '--strict' do
-        let(:op){ 
-          a_lispy.defaults(operand, {:id => lambda{12}}, :strict => true)
-        }
-        let(:expected){
-          Heading[:id => String]
-        }
-
-        it {
-          pending "type inference on expressions not implemented" do
-            should eq(expected)
-          end
-        }
-
-        it{ should eq(Heading[:id => Object]) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/defaults/test_keys.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Defaults, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String).
-                   with_keys([ :id ])
-      }
-      let(:op){ 
-        a_lispy.defaults(operand, {:id => lambda{12}})
-      }
-      let(:expected){
-        Keys[ [ :id ] ]
-      }
-
-      subject{ op.keys }
-
-      it{ should eq(expected) }
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/extend/test_heading.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Extend, 'heading' do
-
-      let(:operand){
-        an_operand.with_heading(:name => String)
-      }
-      let(:op){ 
-        a_lispy.extend(operand, :computed => lambda{ 12 })
-      }
-
-      subject{ op.heading }
-
-      context 'with proper expression analysis' do
-        let(:expected){
-          Heading[:name => String, :computed => Integer]
-        }
-
-        it { 
-          pending "type inference on expressions not implemented" do
-            should eq(expected)
-          end
-        }
-      end
-
-      context 'with current expression analysis' do
-        let(:expected){
-          Heading[:name => String, :computed => Object]
-        }
-
-        it { should eq(expected) }
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/extend/test_keys.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Extend, 'keys' do
-
-      let(:operand){
-        an_operand.with_heading(:id => Integer, :name => String).
-                   with_keys([ :id ], [ :name ])
-      }
-      subject{ op.keys }
-
-      context "when no key is touched by extensions" do
-        let(:op){ 
-          a_lispy.extend(operand, :computed => lambda{ 12 })
-        }
-
-        it { should eq(Keys[ [ :id ], [ :name ] ]) }
-      end
-
-      context "when keys are touched by extensions" do
-        let(:op){ 
-          a_lispy.extend(operand, :name => lambda{ 12 })
-        }
-
-        it { should eq(Keys[ [ :id ] ]) }
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'type_check_helper'
-module Alf
-  module Algebra
-    describe Extend, 'type_check' do
-
-      subject{ op.type_check }
-
-      context 'when ok' do
-        let(:op){ 
-          extend(suppliers, foo: 12)
-        }
-
-        it{ should eq(op.heading) }
-      end
-
-      context 'when clash attribute' do
-        let(:op){ 
-          extend(suppliers, sid: ->{}, foo: 12)
-        }
-
-        it 'should raise an error' do
-          lambda{
-            subject
-          }.should raise_error(TypeCheckError, /cannot override `sid`/)
-        end
-      end
-
-      context 'when unexisting attributes' do
-        let(:op){ 
-          extend(suppliers, sid: ->{}, name: ->{}, bar: String)
-        }
-
-        it 'should raise an error' do
-          lambda{
-            subject
-          }.should raise_error(TypeCheckError, /cannot override `sid`,`name`/)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'type_check_helper'
-module Alf
-  module Algebra
-    describe Frame, 'type_check' do
-
-      subject{ op.type_check }
-
-      context 'when ok' do
-        let(:op){ 
-          frame(suppliers, [], 2, 4)
-        }
-
-        it{ should eq(op.heading) }
-      end
-
-      context 'when invalid ordering' do
-        let(:op){ 
-          frame(suppliers, [[:sid, :asc], [:foo, :asc], [:bar, :asc]], 2, 4)
-        }
-
-        it 'should raise an error' do
-          lambda{
-            subject
-          }.should raise_error(TypeCheckError, /no such attributes `foo`,`bar`/)
-        end
-      end
-
-      context 'when negative offset' do
-        let(:op){ 
-          frame(suppliers, [[:sid, :asc]], -2, 4)
-        }
-
-        it 'should raise an error' do
-          lambda{
-            subject
-          }.should raise_error(TypeCheckError, /invalid offset `-2`/)
-        end
-      end
-
-      context 'when negative limit' do
-        let(:op){ 
-          frame(suppliers, [[:sid, :asc]], 2, -4)
-        }
-
-        it 'should raise an error' do
-          lambda{
-            subject
-          }.should raise_error(TypeCheckError, /invalid limit `-4`/)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/generator/test_heading.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Generator, 'heading' do
-
-      subject{ op.heading }
-
-      let(:op){ 
-        a_lispy.generator(10, :auto)
-      }
-      let(:expected){
-        Heading[:auto => Integer]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end

data/spec/unit/alf-algebra/operator/generator/test_keys.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Algebra
-    describe Generator, 'keys' do
-
-      subject{ op.keys }
-
-      let(:op){ 
-        a_lispy.generator(10, :auto)
-      }
-      let(:expected){
-        Keys[ [ :auto ] ]
-      }
-
-      it { should eq(expected) }
-
-    end
-  end
-end