alf-core 0.14.0 → 0.15.0

data/spec/unit/alf-algebra/support/test_non_relational.rb

@@ -13,8 +13,7 @@ module Alf
           Compact,
           Defaults,
           Generator,
-          Sort,
-          TypeSafe
+          Sort
         ]
       end
     

data/spec/unit/alf-algebra/support/test_relational.rb

@@ -7,11 +7,11 @@ module Alf
         x = []
         Relational.each{|m| x << m}
         x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
+          Allbut,
           Extend,
           Frame,
           Group,
           Hierarchize,
-          InferHeading,
           Intersect,
           Join,
           Matching,

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

@@ -0,0 +1,65 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "allbut" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      shared_examples_for "a compacted compilation result" do
+
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Compact cog' do
+          subject.should be_a(Engine::Compact)
+        end
+
+        it 'has a Clip sub-cog' do
+          subject.operand.should be_a(Engine::Clip)
+          subject.operand.attributes.should eq(AttrList[:a])
+          subject.operand.allbut.should be_true
+        end
+
+        it 'has the corect sub-sub cog' do
+          subject.operand.operand.should be(leaf)
+        end
+      end
+
+      context 'when keys not available' do
+        let(:expr){
+          allbut(an_operand(leaf), [:a])
+        }
+
+        it_should_behave_like "a compacted compilation result"
+      end
+
+      context 'when keys are available and not preserving' do
+        let(:expr){
+          allbut(an_operand(leaf).with_keys([:a]), [:a])
+        }
+
+        it_should_behave_like "a compacted compilation result"
+      end
+
+      context 'when keys are available and preserving' do
+        let(:expr){
+          allbut(an_operand(leaf).with_keys([:b]), [:a])
+        }
+
+        it_should_behave_like "a traceable cog"
+
+        it 'has a Clip cog' do
+          subject.should be_a(Engine::Clip)
+          subject.attributes.should eq(AttrList[:a])
+          subject.allbut.should be_true
+        end
+
+        it 'has the correct sub cog' do
+          subject.operand.should be(leaf)
+        end
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "clip" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        clip(an_operand(leaf), [:a])
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Clip cog' do
+        subject.should be_a(Engine::Clip)
+      end
+
+      it 'has the correct clipping attributes' do
+        subject.attributes.should eq(AttrList[: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_coerce.rb

@@ -0,0 +1,30 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "coerce" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      let(:expr){
+        coerce(an_operand(leaf), a: String)
+      }
+
+      it_should_behave_like "a traceable compiled"
+
+      it 'has a Coerce cog' do
+        subject.should be_a(Engine::Coerce)
+      end
+
+      it 'has the correct coercion heading' do
+        subject.coercions.should eq(Heading[a: String])
+      end
+
+      it 'has the correct sub-cog' do
+        subject.operand.should be(leaf)
+      end
+
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "completude over algebra" do
+
+      Algebra::Operator.registered.each do |operator|
+        next if operator.ancestors.include?(Algebra::Shortcut)
+
+        it "support #{operator}" do
+          compiler.should respond_to(:"on_#{operator.rubycase_name}")
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'compiler_helper'
+module Alf
+  class Compiler
+    describe Default, "defaults" do
+
+      subject{
+        compiler.call(expr)
+      }
+
+      shared_examples_for 'the expected Defaults' do
+
+        it_should_behave_like "a traceable compiled"
+
+        it 'has a Defaults cog' do
+          subject.should be_a(Engine::Defaults)
+        end
+
+        it 'has the correct defaults' do
+          subject.defaults.to_hash.should eq(b: 1)
+        end
+      end
+
+      context "when non strict" do
+        let(:expr){
+          defaults(an_operand(leaf), b: 1)
+        }
+
+        it_should_behave_like "the expected Defaults"
+
+        it 'has the correct sub-cog' do
+          subject.operand.should be(leaf)
+        end
+      end
+
+      context "when strict" do
+        let(:expr){
+          defaults(an_operand(leaf), {b: 1}, strict: true)
+        }
+
+        it_should_behave_like "the expected Defaults"
+
+        it 'has a Clip sub-sub cog' do
+          subject.operand.should be_a(Engine::Clip)
+          subject.operand.attributes.should eq(AttrList[:b])
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,38 @@
+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