alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-compiler/default/test_extend.rb

@@ -1,34 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "extend" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:expr){
-        extend(an_operand(leaf), computation)
-      }
-
-      let(:computation){
-        TupleComputation[{ foo: "12" }]
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a SetAttr cog' do
-        subject.should be_a(Engine::SetAttr)
-      end
-
-      it 'has the correct computation' do
-        subject.computation.should be(computation)
-      end
-
-      it 'has the correct sub-cog' do
-        subject.operand.should be(leaf)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_frame.rb

@@ -1,77 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "frame" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:ordering){
-        Ordering.new([[:a, :asc]])
-      }
-
-      shared_examples_for "the expected Take" do
-        it_should_behave_like "a traceable compiled"
-
-        it 'has a Take cog' do
-          subject.should be_a(Engine::Take)
-        end
-
-        it 'has the correct take attributes' do
-          subject.offset.should eq(10)
-          subject.limit.should eq(20)
-        end
-      end
-
-      context 'when not already sorted' do
-        let(:expr){
-          frame(an_operand(leaf), ordering, 10, 20)
-        }
-
-        it_should_behave_like "the expected Take"
-        it_should_behave_like "a compiled based on an added sub Sort"
-      end
-
-      context 'when not already sorted (inference possible)' do
-        let(:expr){
-          op = an_operand(leaf).with_heading(a: String, b: String)
-                               .with_keys([:b])
-          frame(op, ordering, 10, 20)
-        }
-
-        let(:total_ordering){
-          Ordering.new([[:a, :asc], [:b, :asc]])
-        }
-
-        it_should_behave_like "the expected Take"
-        it_should_behave_like "a compiled based on an added sub Sort with total ordering"
-      end
-
-      context 'when already sorted' do
-        let(:expr){
-          frame(sort(an_operand(leaf), subordering), ordering, 10, 20)
-        }
-
-        context 'in a compatible way' do
-          let(:subordering){
-            Ordering.new([[:a, :asc], [:b, :desc]])
-          }
-
-          it_should_behave_like "the expected Take"
-          it_should_behave_like "a compiled reusing a sub Sort"
-        end
-
-        context 'in incompatible way' do
-          let(:subordering){
-            Ordering.new([[:a, :desc]])
-          }
-
-          it_should_behave_like "the expected Take"
-          it_should_behave_like "a compiled not reusing a sub Sort"
-        end
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_generator.rb

@@ -1,30 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "generator" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:expr){
-        generator(100, :foo)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'is a Generator cog' do
-        subject.should be_a(Engine::Generator)
-      end
-
-      it 'has the correct generator attribute name' do
-        subject.as.should eq(:foo)
-      end
-
-      it 'has the correct generator count' do
-        subject.count.should eq(100)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_group.rb

@@ -1,38 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "group" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:expr){
-        group(an_operand(leaf), [:foo, :bar], :baz, allbut: true)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a Group cog' do
-        subject.should be_a(Engine::Group)
-      end
-
-      it 'has the correct grouping' do
-        subject.attributes.should eq(AttrList[:foo, :bar])
-      end
-
-      it 'has the correct as' do
-        subject.as.should eq(:baz)
-      end
-
-      it 'has the correct allbut' do
-        subject.allbut.should be_true
-      end
-
-      it 'has the correct sub-cog' do
-        subject.operand.should be(leaf)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_hierarchize.rb

@@ -1,40 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Compiler, 'on_hierarchize' do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:operand){
-        an_operand.with_heading(id: Fixnum, parent: Integer).with_keys([:id])
-      }
-
-      let(:expr){
-        a_lispy.hierarchize(an_operand(leaf), :id, :parent, :as)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      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
-
-      it 'has the correct sub-cog' do
-        subject.operand.should be(leaf)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_intersect.rb

@@ -1,34 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "intersect" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:right){
-        compact(an_operand(leaf))
-      }
-
-      let(:expr){
-        intersect(an_operand(leaf), right)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a Join::Hash cog' do
-        subject.should be_a(Engine::Join::Hash)
-      end
-
-      it 'has the correct left sub-cog' do
-        subject.left.should be(leaf)
-      end
-
-      it 'has the correct right sub-cog' do
-        subject.right.should be_a(Engine::Compact)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_join.rb

@@ -1,34 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "join" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:right){
-        compact(an_operand)
-      }
-
-      let(:expr){
-        join(an_operand(leaf), right)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'is a Join::Hash cog' do
-        subject.should be_a(Engine::Join::Hash)
-      end
-
-      it 'has the correct left sub-cog' do
-        subject.left.should be(leaf)
-      end
-
-      it 'has the correct right sub-cog' do
-        subject.right.should be_a(Engine::Compact)
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_matching.rb

@@ -1,38 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "matching" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:right){
-        compact(an_operand(leaf))
-      }
-
-      let(:expr){
-        matching(an_operand(leaf), right)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a Join::Hash cog' do
-        subject.should be_a(Engine::Semi::Hash)
-      end
-
-      it 'has the correct left sub-cog' do
-        subject.left.should be(leaf)
-      end
-
-      it 'has the correct right sub-cog' do
-        subject.right.should be_a(Engine::Compact)
-      end
-
-      it 'has the correct predicate' do
-        subject.predicate.should be_true
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_minus.rb

@@ -1,38 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "minus" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:right){
-        compact(an_operand(leaf))
-      }
-
-      let(:expr){
-        minus(an_operand(leaf), right)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a Join::Hash cog' do
-        subject.should be_a(Engine::Semi::Hash)
-      end
-
-      it 'has the correct left sub-cog' do
-        subject.left.should be(leaf)
-      end
-
-      it 'has the correct right sub-cog' do
-        subject.right.should be_a(Engine::Compact)
-      end
-
-      it 'has the correct predicate' do
-        subject.predicate.should be_false
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_not_matching.rb

@@ -1,38 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "not_matching" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:right){
-        compact(an_operand(leaf))
-      }
-
-      let(:expr){
-        not_matching(an_operand(leaf), right)
-      }
-
-      it_should_behave_like "a traceable compiled"
-
-      it 'has a Join::Hash cog' do
-        subject.should be_a(Engine::Semi::Hash)
-      end
-
-      it 'has the correct left sub-cog' do
-        subject.left.should be(leaf)
-      end
-
-      it 'has the correct right sub-cog' do
-        subject.right.should be_a(Engine::Compact)
-      end
-
-      it 'has the correct predicate' do
-        subject.predicate.should be_false
-      end
-
-    end
-  end
-end

data/spec/unit/alf-compiler/default/test_page.rb

@@ -1,91 +0,0 @@
-require 'compiler_helper'
-module Alf
-  class Compiler
-    describe Default, "page" do
-
-      subject{
-        compiler.call(expr)
-      }
-
-      let(:ordering){
-        Ordering.new([[:a, :asc]])
-      }
-
-      shared_examples_for "the expected Take" do
-        it_should_behave_like "a traceable compiled"
-
-        it 'has a Take cog' do
-          subject.should be_a(Engine::Take)
-        end
-
-        it 'has the correct take attributes' do
-          subject.offset.should eq(40)
-          subject.limit.should eq(20)
-        end
-      end
-
-      context 'when positive page (no inference possible)' do
-        let(:expr){
-          page(an_operand(leaf), ordering, 3, page_size: 20)
-        }
-
-        it_should_behave_like "the expected Take"
-        it_should_behave_like "a compiled based on an added sub Sort"
-
-        it "should have the expected Sort" do
-          subject.operand.should be_a(Engine::Sort)
-          subject.operand.ordering.should eq(ordering)
-        end
-      end
-
-      context 'when positive page (inference possible)' do
-        let(:expr){
-          op = an_operand(leaf).with_heading(a: String, b: String)
-                               .with_keys([:b])
-          page(op, ordering, 3, page_size: 20)
-        }
-
-        let(:total_ordering){
-          Ordering.new([[:a, :asc], [:b, :asc]])
-        }
-
-        it_should_behave_like "the expected Take"
-        it_should_behave_like "a compiled based on an added sub Sort with total ordering"
-      end
-
-      context 'when a negative page' do
-        let(:expr){
-          page(an_operand(leaf), ordering, -3, page_size: 20)
-        }
-
-        it_should_behave_like "the expected Take"
-        it_should_behave_like "a compiled based on an added reversed Sort"
-      end
-
-      context 'when already sorted' do
-        let(:expr){
-          page(sort(an_operand(leaf), subordering), ordering, 3, page_size: 20)
-        }
-
-        context 'in a compatible way' do
-          let(:subordering){
-            Ordering.new([[:a, :asc], [:b, :desc]])
-          }
-
-          it_should_behave_like "the expected Take"
-          it_should_behave_like "a compiled reusing a sub Sort"
-        end
-
-        context 'in incompatible way' do
-          let(:subordering){
-            Ordering.new([[:a, :desc]])
-          }
-
-          it_should_behave_like "the expected Take"
-          it_should_behave_like "a compiled not reusing a sub Sort"
-        end
-      end
-
-    end
-  end
-end