alf-core 0.14.0 → 0.15.0

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

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

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

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

data/spec/unit/alf-engine/compiler/test_on_frame.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compiler, 'test_on_frame' do
-
-      subject{ Compiler.new.call(expr) }
-
-      shared_examples_for "a traceable take" do
-        it_should_behave_like "a traceable cog"
-
-        it {
-          should be_a(Engine::Take)
-        }
-      end
-
-      context 'when keys are known and a positive index' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.frame(operand, [], 3, 8)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have correct offset' do
-          subject.offset.should eq(3)
-        end
-
-        it 'should have correct limit' do
-          subject.limit.should eq(8)
-        end
-
-        it 'should have a sort as child' do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
-        end
-
-        it 'should have a leaf as child.child' do
-          subject.operand.operand.should be_a(Leaf)
-        end
-      end
-
-      context 'when keys and heading are not supported' do
-        let(:operand){
-          an_operand
-        }
-        let(:expr){
-          a_lispy.frame(operand, [[:id, :asc]], 3, 8)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have correct offset' do
-          subject.offset.should eq(3)
-        end
-
-        it 'should have correct limit' do
-          subject.limit.should eq(8)
-        end
-
-        it 'should have a sort as child and stick to initial ordering' do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/compiler/test_on_hierarchize.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compiler, 'test_on_hierarchize' do
-
-      subject{ Compiler.new.call(expr) }
-
-      context 'the normal case' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, parent: Integer).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.hierarchize(operand, :id, :parent, :as)
-        }
-
-        it{ should be_a(Engine::Hierarchize) }
-
-        it 'should have correct id list' do
-          subject.id.should eq(AttrList[:id])
-        end
-
-        it 'should have correct parent list' do
-          subject.parent.should eq(AttrList[:parent])
-        end
-
-        it 'should have correct children name' do
-          subject.children.should eq(:as)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/compiler/test_on_page.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compiler, 'test_on_page' do
-
-      subject{ Compiler.new.call(expr) }
-
-      shared_examples_for "a traceable take" do
-        it_should_behave_like "a traceable cog"
-
-        it {
-          should be_a(Engine::Take)
-        }
-      end
-
-      context 'when keys are known and a positive index' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.page(operand, [], 3, page_size: 8)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have correct offset' do
-          subject.offset.should eq(16)
-        end
-
-        it 'should have correct limit' do
-          subject.limit.should eq(8)
-        end
-
-        it 'should have a sort as child' do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
-        end
-
-        it 'should have a leaf as child.child' do
-          subject.operand.operand.should be_a(Leaf)
-        end
-      end
-
-      context 'when keys are known and a page 1' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.page(operand, [], 1)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have offset 0' do
-          subject.offset.should eq(0)
-        end
-      end
-
-      context 'when keys are known and a negative index' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.page(operand, [], -3, page_size: 8)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have correct offset' do
-          subject.offset.should eq(16)
-        end
-
-        it 'should have correct limit' do
-          subject.limit.should eq(8)
-        end
-
-        it 'should have a sort with inverse ordering as child' do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(Ordering.new([[:id, :desc]]))
-        end
-
-        it 'should have a leaf as child.child' do
-          subject.operand.operand.should be_a(Leaf)
-        end
-      end
-
-      context 'when keys are known and a page -1' do
-        let(:operand){
-          an_operand.with_heading(id: Fixnum, name: String).with_keys([:id])
-        }
-        let(:expr){
-          a_lispy.page(operand, [], -1)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have offset 0' do
-          subject.offset.should eq(0)
-        end
-      end
-
-      context 'when keys and heading are not supported' do
-        let(:operand){
-          an_operand
-        }
-        let(:expr){
-          a_lispy.page(operand, [[:id, :asc]], 3, page_size: 8)
-        }
-
-        it_should_behave_like "a traceable take"
-
-        it 'should have correct offset' do
-          subject.offset.should eq(16)
-        end
-
-        it 'should have correct limit' do
-          subject.limit.should eq(8)
-        end
-
-        it 'should have a sort as child and stick to initial ordering' do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(Ordering.new([[:id, :asc]]))
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-engine/compiler/test_unsupported.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Engine
-    describe Compiler, 'unsupported' do
-
-      def unsupported(*args, &bl)
-        Compiler.new.send(:unsupported, *args, &bl)
-      end
-
-      context 'when nothing raised' do
-
-        subject{
-          unsupported(:fall){ 12 }
-        }
-
-        it 'should return the value if nothing raised' do
-          subject.should eq(12)
-        end
-      end
-
-      context 'when a NotSupportedError is raised' do
-
-        subject{
-          unsupported(:fall){ raise NotSupportedError }
-        }
-
-        it 'should return the fallback value' do
-          subject.should eq(:fall)
-        end
-      end
-
-      context 'when something else is raised' do
-
-        subject{
-          unsupported(:fall){ raise ArgumentError, "here" }
-        }
-
-        it 'should let the error be raised' do
-          lambda{
-            subject
-          }.should raise_error(ArgumentError, "here")
-        end
-      end
-
-
-    end
-  end
-end

data/spec/unit/alf-lang/lispy/test_connection_bang.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe Lispy, 'connection!' do
-
-      context 'when bound' do
-        let(:lispy){ Lispy.new([], 12) }
-
-        it 'allows obtaining its connection' do
-          lispy.connection!.should eq(12)
-        end
-      end
-
-      context 'when unbound' do
-        let(:lispy){ Lispy.new }
-
-        it 'raises when connection is used without being bound' do
-          lambda{
-            lispy.connection!
-          }.should raise_error(UnboundError)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/lispy/test_parse.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe Lispy do
-
-      context 'when unbound' do
-        let(:lispy){ Lispy.new }
-
-        it 'allows parsing predicate expressions' do
-          p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
-          p.should be_a(Alf::Predicate)
-        end
-
-        it 'allows parsing relational expressions' do
-          p = lispy.parse{ project(:suppliers, [:sid]) }
-          p.should be_a(Algebra::Project)
-        end
-      end
-
-      context 'when bound' do
-        let(:lispy){ Lispy.new([], 12) }
-
-        it 'allows parsing predicate expressions' do
-          p = lispy.parse{ eq(:x, 1) & neq(:y, 2) }
-          p.should be_a(Alf::Predicate)
-        end
-
-        it 'deeply binds parsed relational expressions' do
-          p = lispy.parse{ project(:suppliers, [:sid]) }
-          p.should be_a(Algebra::Project)
-          p.connection!.should eq(12)
-          p.operand.connection!.should eq(12)
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-lang/lispy/test_to_s.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Lang
-    describe Lispy, 'to_s' do
-
-      let(:lispy){ Lispy.new }
-
-      subject{ lispy.to_s }
-
-      it{ should eq("Lispy()") }
-
-    end
-  end
-end

data/spec/unit/alf-optimizer/optimizer/test_optimizer.rb

@@ -1,37 +0,0 @@
-require 'optimizer_helper'
-module Alf
-  class Optimizer
-    describe Search do
-
-      let(:operand_1){ an_operand.with_heading(:id => String) }
-
-      # replaces project by clip
-      let(:processor_1){
-        lambda{|expr, search|
-          clip(search.apply(expr.operand), expr.attributes, :allbut => expr.allbut)
-        }
-      }
-      # adds an autonum before rename 
-      let(:processor_2){
-        lambda{|expr, search| autonum(search.copy_and_apply(expr), :auto) }
-      }
-      let(:optimizer){
-        Optimizer.new.register(processor_1, Algebra::Project).
-                      register(processor_2, Algebra::Rename)
-      }
-
-      subject{ optimizer.call(expr) }
-
-      let(:expr){
-        (project (rename (project operand_1, [:bar]), :foo => :bar), [:foo])
-      }
-
-      let(:expected){
-        (clip (autonum (rename (clip operand_1, [:bar]), :foo => :bar), :auto), [:foo])
-      }
-
-      it{ should eq(expected) }
-
-    end
-  end
-end