alf-core 0.14.0 → 0.15.0

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

@@ -0,0 +1,71 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "rank" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:ordering){
+        Ordering.new([[:a, :asc]])
+      }
+
+      shared_examples_for "the expected Rank::Cesure" do
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Rank::Cesure cog' do
+          subject.should be_a(Engine::Rank::Cesure)
+        end
+
+        it 'has the correct parameters' do
+          subject.by.should eq(AttrList[:a])
+          subject.as.should eq(:foo)
+        end
+      end
+
+      context 'when not sorted' do
+        let(:expr){
+          rank(an_operand(leaf), ordering, :foo)
+        }
+
+        it_should_behave_like "the expected Rank::Cesure"
+        it_should_behave_like "a compiled based on an added sub Sort"
+      end
+
+      context 'when already sorted' do
+        let(:expr){
+          rank(sort(an_operand(leaf), subordering), ordering, :foo)
+        }
+
+        context 'in a compatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :asc], [:b, :desc]])
+          }
+
+          it_should_behave_like "the expected Rank::Cesure"
+          it_should_behave_like "a compiled reusing a sub Sort"
+        end
+
+        context 'in a completely different way' do
+          let(:subordering){
+            Ordering.new([[:name, :asc]])
+          }
+
+          it_should_behave_like "the expected Rank::Cesure"
+          it_should_behave_like "a compiled not reusing a sub Sort"
+        end
+
+        context 'in incompatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :desc]])
+          }
+
+          it_should_behave_like "the expected Rank::Cesure"
+          it_should_behave_like "a compiled not reusing a sub Sort"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "rename" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        rename(an_operand(leaf), a: :b)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Rename cog' do
+        subject.should be_a(Engine::Rename)
+      end
+
+      it 'has the correct rename attributes' do
+        subject.renaming.should eq(Renaming[a: :b])
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "restrict" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        restrict(an_operand(leaf), predicate)
+      }
+
+      let(:predicate){
+        Predicate.native(->{ true })
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Filter cog' do
+        subject.should be_a(Engine::Filter)
+      end
+
+      it 'has the correct predicate' do
+        subject.predicate.should be(predicate)
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "sort" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:ordering){
+        Ordering.new([[:a, :asc]])
+      }
+
+      shared_examples_for "the expected Sort" do
+        it_should_behave_like "a traceable compiled"
+
+        it{ should be_a(Engine::Sort) }
+      end
+
+      context 'when the cog is not sorted at all' do
+        let(:expr){
+          sort(an_operand(leaf), ordering)
+        }
+
+        it_should_behave_like "the expected Sort"
+
+        it 'should add a Sort' do
+          subject.ordering.should be(ordering)
+          subject.operand.should be(leaf)
+        end
+      end
+
+      context 'when the cog is already sorted' do
+        let(:expr){
+          sort(sort(an_operand(leaf), subordering), ordering)
+        }
+
+        context 'in exact same way' do
+          let(:subordering){
+            Ordering.new([[:a, :asc]])
+          }
+
+          it_should_behave_like "the expected Sort"
+
+          it 'should reuse the cog itself' do
+            subject.operand.should be(leaf)
+            subject.ordering.should be(subordering)
+          end
+        end
+
+        context 'in a compatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :asc], [:b, :desc]])
+          }
+
+          it_should_behave_like "the expected Sort"
+
+          it 'should reuse the cog itself' do
+            subject.operand.should be(leaf)
+            subject.ordering.should be(subordering)
+          end
+        end
+
+        context 'in a incompatible way' do
+          let(:subordering){
+            Ordering.new([[:a, :desc]])
+          }
+
+          it_should_behave_like "the expected Sort"
+
+          it 'should add a Sort' do
+            subject.ordering.should be(ordering)
+            subject.operand.should be_a(Engine::Sort)
+            subject.operand.ordering.should be(subordering)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "summarize" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:by){
+        AttrList[:a]
+      }
+
+      let(:summarization){
+        Summarization[{ max: Aggregator.max{ qty } }]
+      }
+
+      let(:expr){
+        summarize(an_operand(leaf), by, summarization, allbut: allbut)
+      }
+
+      shared_examples_for "the expected Summarize" do
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Summarize' do
+          subject.should be_a(Engine::Summarize)
+        end
+
+        it 'has correct parameters' do
+          subject.by.should eq(by)
+          subject.summarization.should eq(summarization)
+          subject.allbut.should eq(allbut)
+        end
+      end
+
+      context 'when allbut' do
+        let(:allbut){ true }
+
+        it 'has a Summarize::Hash' do
+          subject.should be_a(Engine::Summarize::Hash)
+        end
+
+        it_should_behave_like "the expected Summarize"
+
+        it 'has correct sub-cog' do
+          subject.operand.should be(leaf)
+        end
+      end
+
+      context 'when not allbut' do
+        let(:allbut){ false }
+        let(:ordering){
+          Ordering.new([[:a, :asc]])
+        }
+
+        context 'when not already ordered' do
+          it 'has a Summarize::Cesure' do
+            subject.should be_a(Engine::Summarize::Cesure)
+          end
+
+          it_should_behave_like "the expected Summarize"
+          it_should_behave_like "a compiled based on an added sub Sort"
+        end
+
+        context 'when already in good direction' do
+          let(:expr){
+            summarize(sort(an_operand(leaf), subordering), by, summarization, allbut: allbut)
+          }
+
+          let(:subordering){
+            Ordering.new([[:a, :asc]])
+          }
+
+          it 'has a Summarize::Cesure' do
+            subject.should be_a(Engine::Summarize::Cesure)
+          end
+
+          it_should_behave_like "the expected Summarize"
+          it_should_behave_like "a compiled reusing a sub Sort"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "ungroup" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        ungroup(an_operand(leaf), :a)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Ungroup cog' do
+        subject.should be_a(Engine::Ungroup)
+      end
+
+      it 'has the correct ungrouping attribute' do
+        subject.attribute.should eq(:a)
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "union" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:right){
+        clip(an_operand(leaf), [:a])
+      }
+
+      let(:expr){
+        union(an_operand(leaf), right)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Compact cog' do
+        subject.should be_a(Engine::Compact)
+      end
+
+      it 'has a Concat sub-cog' do
+        subject.operand.should be_a(Engine::Concat)
+      end
+
+      it 'has the correct sub-sub-cogs' do
+        ops = subject.operand.operands
+        ops.first.should be(leaf)
+        ops.last.should be_a(Engine::Clip)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "unwrap" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        unwrap(an_operand(leaf), :a)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Unwrap cog' do
+        subject.should be_a(Engine::Unwrap)
+      end
+
+      it 'has the correct unwrapping attribute' do
+        subject.attribute.should eq(:a)
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "wrap" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        wrap(an_operand(leaf), [:foo, :bar], :baz, allbut: true)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Wrap cog' do
+        subject.should be_a(Engine::Wrap)
+      end
+
+      it 'has the correct wrapping' 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/shared/compiled_examples.rb

@@ -0,0 +1,111 @@
+shared_examples_for 'a compiled' do
+
+  it { should be_a(Alf::Compiler::Cog) }
+
+  it 'should return self on to_cog' do
+    subject.to_cog.should be(subject)
+  end
+
+end
+
+shared_examples_for 'a traceable compiled' do
+
+  it_should_behave_like "a compiled"
+
+  def has_tracking!(compiled)
+    compiled.expr.should_not be_nil
+    case compiled
+    when Alf::Engine::Leaf
+      compiled.expr.should be_a(Alf::Algebra::Operand)
+    when Alf::Engine::Cog
+      compiled.expr.should be_a(Alf::Algebra::Operand)
+      extract_operands(compiled).each do |op|
+        has_tracking!(op)
+      end
+    else
+      raise "Unexpected cog: #{compiled}"
+    end
+  end
+
+  def extract_operands(compiled)
+    return compiled.operands if compiled.respond_to?(:operands)
+    return [compiled.operand] if compiled.respond_to?(:operand)
+    []
+  end
+
+  it 'should have the compiler' do
+    subject.compiler.should be(compiler)
+  end
+
+  it 'should have traceability all way down expression' do
+    has_tracking!(subject)
+  end
+
+end
+
+shared_examples_for "a compiled not reusing a sub Sort" do
+
+  it 'has a Sort as sub-cog' do
+    subject.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.ordering.should eq(ordering)
+  end
+
+  it 'has a Sort has sub-sub cog' do
+    subject.operand.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.operand.ordering.should be(subordering)
+  end
+
+  it 'has the leaf has sub-sub-sub cog' do
+    subject.operand.operand.operand.should be(leaf)
+  end
+
+end
+
+shared_examples_for "a compiled based on an added sub Sort" do
+
+  it 'has a Sort as sub-cog' do
+    subject.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.ordering.should eq(ordering)
+  end
+
+  it 'has the leaf has sub-sub cog' do
+    subject.operand.operand.should be(leaf)
+  end
+
+end
+
+shared_examples_for "a compiled based on an added sub Sort with total ordering" do
+
+  it 'has a Sort as sub-cog' do
+    subject.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.ordering.should eq(total_ordering)
+  end
+
+  it 'has the leaf has sub-sub cog' do
+    subject.operand.operand.should be(leaf)
+  end
+
+end
+
+shared_examples_for "a compiled based on an added reversed Sort" do
+
+  it 'has a Sort as sub-cog' do
+    subject.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.ordering.should eq(ordering.reverse)
+  end
+
+  it 'has the leaf has sub-sub cog' do
+    subject.operand.operand.should be(leaf)
+  end
+
+end
+
+shared_examples_for "a compiled reusing a sub Sort" do
+
+  it 'has the Sort as sub-cog' do
+    subject.operand.should be_a(Alf::Engine::Sort)
+    subject.operand.ordering.should be(subordering)
+    subject.operand.operand.should be(leaf)
+  end
+
+end