alf-core 0.15.0 → 0.16.0

data/spec/unit/alf-types/summarization/test_least.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Summarization, "least" do
-
-    it 'should invoke least on each aggregator' do
-      sum = Summarization.coerce(["s", Aggregator.avg{ qty }, "m", Aggregator.max{ size }])
-      sum.least.should eq({:s => [0.0, 0.0], :m => nil})
-    end
-
-  end
-end

data/spec/unit/alf-types/summarization/test_summarize.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Summarization, "summarize" do
-
-    it 'should summarize as expected' do
-      rel = [
-        {:qty => 10, :size => 12},
-        {:qty => 5,  :size => 5}
-      ]
-      sum = Summarization.coerce(["s", Aggregator.avg{ qty }, "m", Aggregator.max{ size }])
-      sum.summarize(rel).should eq({:s => 7.5, :m => 12})
-    end
-
-  end
-end

data/spec/unit/alf-types/test_attr_list.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe AttrList do
-
-    def AttrList.exemplars
-      [
-        [],
-        [:a],
-        [:a, :b]
-      ].map{|arg| AttrList.coerce(arg) }
-    end
-
-    let(:type){ AttrList }
-
-    it_should_behave_like 'A valid type implementation'
-
-  end
-end

data/spec/unit/alf-types/test_class_methods.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Types do
-    include Types
-
-    describe "common_super_type" do
-
-      it 'works on same types' do
-        common_super_type(String, String).should eq(String)
-      end
-
-      it 'works with related types' do
-        common_super_type(Fixnum, Integer).should eq(Integer)
-        common_super_type(Fixnum, Float).should eq(Numeric)
-      end
-
-      it 'fallbacks to Object' do
-        common_super_type(Fixnum, String).should eq(Object)
-      end
-
-      it 'works nicely on same relation types' do
-        left  = Relation[pid: String]
-        right = Relation[pid: String]
-        common_super_type(left, right).should eq(left)
-      end
-
-      it 'works nicely on compatible relation types' do
-        left  = Relation[pid: Fixnum]
-        right = Relation[pid: Integer]
-        common_super_type(left, right).should eq(right)
-      end
-
-      it 'works nicely on same tuple types' do
-        left  = Tuple[pid: String]
-        right = Tuple[pid: String]
-        common_super_type(left, right).should eq(left)
-      end
-
-      it 'works nicely on compatible relation types' do
-        left  = Tuple[pid: Fixnum]
-        right = Tuple[pid: Integer]
-        common_super_type(left, right).should eq(right)
-      end
-
-      it 'fallbacks to Tuple when tuple types do not agree' do
-        left  = Tuple[pid: String]
-        right = Tuple[{}]
-        common_super_type(left, right).should eq(Tuple)
-      end
-
-      it 'fallbacks to Relation when relation types do not agree' do
-        left  = Relation[pid: String]
-        right = Relation[{}]
-        common_super_type(left, right).should eq(Relation)
-      end
-    end
-
-  end # describe Types
-end # module Alf

data/spec/unit/alf-types/test_heading.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Heading do
-
-    describe "the class itself" do
-      let(:type){ Heading }
-      def Heading.exemplars
-        [
-          {},
-          {:a => String},
-          {:a => String, :b => Date}
-        ].map{|x| Heading.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    let(:h0){ Heading.new({}) }
-    let(:h1){ Heading.new(:name => String) }
-    let(:h2){ Heading.new(:name => String, :price => Float) }
-
-    it 'should be Enumerable' do
-      h2.map{|k,v| [k,v]}.to_set.should eq([[:name, String], [:price, Float]].to_set)
-    end
-
-    describe "[]" do
-
-      specify "it should mimic coerce" do
-        Heading[:name => String].should eq(h1)
-        Heading["name" => "String"].should eq(h1)
-        Heading[{}].should eq(h0)
-        Heading[[]].should eq(h0)
-        Heading[["name", "String"]].should eq(h1)
-      end
-
-      specify "should raise ArgumentError on error" do
-        lambda{ Heading[true] }.should raise_error(TypeError)
-      end
-
-    end # []
-
-    describe "EMPTY" do
-      subject{ Heading::EMPTY }
-      it{ should be_a(Heading) }
-      it_should_behave_like "A value"
-    end
-
-    describe "h0" do
-      subject{ h0 }
-      it { should == Heading::EMPTY }
-      it_should_behave_like "A value" 
-    end
-
-    describe "h1" do
-      subject{ h1 }
-      it_should_behave_like "A value" 
-    end
-
-  end 
-end

data/spec/unit/alf-types/test_ordering.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Ordering do
-
-    def Ordering.exemplars
-      [
-        [],
-        [:a],
-        [[:a, :asc], [:b, :asc]]
-      ].map{|x| Ordering.coerce(x)}
-    end
-
-    let(:type){ Ordering }
-
-    it_should_behave_like 'A valid type implementation'
-
-  end # Ordering
-end # Alf

data/spec/unit/alf-types/test_renaming.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming do
-
-    def Renaming.exemplars
-      [
-        {},
-        {:old1 => :new1},
-        {:old1 => :new1, :old2 => :new2}
-      ].map{|x| Renaming.coerce(x)}
-    end
-
-    let(:type){ Renaming }
-
-    it_should_behave_like 'A valid type implementation'
-
-  end # Renaming
-end # Alf

data/spec/unit/alf-types/test_summarization.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Summarization do
-
-    describe "the class itself" do
-      let(:type){ Summarization }
-      def Summarization.exemplars
-        [
-          ["total", Aggregator.sum{ qty }]
-        ].map{|x| Summarization.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    specify "least -> happens -> finalize" do
-      scope = Support::TupleScope.new
-      summ = Summarization.coerce(["s", Aggregator.sum{ qty }, "m", Aggregator.max{ size }])
-      (x = summ.least).should eql(:s => 0, :m => nil)
-      (x = summ.happens(x, scope.__set_tuple(:qty => 10, :size => 12))).should eq(:s => 10, :m => 12)
-      (x = summ.happens(x, scope.__set_tuple(:qty => 5, :size => 5))).should eq(:s => 15, :m => 12)
-      summ.finalize(x).should eq(:s => 15, :m => 12)
-    end
-
-  end
-end

data/spec/unit/alf-types/test_tuple_computation.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation do
-
-    describe "the class itself" do
-      let(:type){ TupleComputation }
-      def TupleComputation.exemplars
-        [
-          {status: 10},
-          {big?: "status > 10"}
-        ].map{|x| TupleComputation.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    it 'should have a valid example' do
-      computation = TupleComputation[
-        big?: lambda{ status > 20 },
-        who:  lambda{ "#{first} #{last}" }
-      ]
-      res = computation.call(last: "Jones", first: "Bill", status: 10)
-      res.should eq(big?: false, who: "Bill Jones")
-    end
-
-    let(:scope){ Support::TupleScope.new(who: "alf") }
-
-  end
-end

data/spec/unit/alf-types/test_tuple_expression.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleExpression do
-
-    def TupleExpression.exemplars
-      [
-        ->{ 10 },
-        ->(t){ t.status > 10 },
-      ].map{|x| TupleExpression.coerce(x)}
-    end
-
-    let(:type){ TupleExpression }
-
-    it_should_behave_like 'A valid type implementation'
-
-  end # TupleExpression
-end # Alf

data/spec/unit/alf-types/tuple_computation/test_coerce.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation, "coerce" do
-
-    subject{ TupleComputation.coerce(arg).evaluate(scope) }
-
-    let(:scope) {
-      Support::TupleScope.new(status: 10, who: "alf")
-    }
-
-    describe "from a TupleComputation" do
-      let(:arg){ TupleComputation.new hello: TupleExpression.coerce(:who) }
-      it{ should eql(hello: "alf") }
-    end
-
-    describe "from a Hash without coercion" do
-      let(:arg){
-        {:hello  => TupleExpression.coerce(:who),
-         :hello2 => ->(t){ t.who } }
-      }
-      let(:expected){
-        {hello: "alf", :hello2 => "alf"}
-      }
-      it{ should eql(expected) }
-    end
-
-    describe "from a Hash with coercion" do
-      let(:arg){
-        {"hello" => :who}
-      }
-      let(:expected){
-        {hello: "alf"}
-      }
-      it{ should eql(expected) }
-    end
-
-    describe "from a Tuple" do
-      let(:arg){ Tuple(hello: TupleExpression.coerce(:who)) }
-      let(:expected){ {hello: "alf"} }
-
-      it{ should eql(expected) }
-    end
-
-  end
-end

data/spec/unit/alf-types/tuple_computation/test_empty.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation, "empty?" do
-
-    subject{ comp.empty? }
-
-    context 'when not empty' do
-      let(:comp){
-        TupleComputation[big?: ->{}, who: ->{}]
-      }
-
-      it{ should be_false }
-    end
-
-    context 'when empty' do
-      let(:comp){
-        TupleComputation[{}]
-      }
-
-      it{ should be_true }
-    end
-
-  end
-end

data/spec/unit/alf-types/tuple_computation/test_project.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation, "project" do
-    big = TupleExpression.coerce(->(t){ t.status > 10 })
-    who = TupleExpression.coerce(->(t){ t.name })
-
-    let(:comp){
-      TupleComputation[big?: big, who: who]
-    }
-
-    subject{ comp.project(list, allbut) }
-
-    context 'when not allbut' do
-      let(:allbut){ false }
-
-      [
-        [ [:big?, :who],  TupleComputation[big?: big, who: who] ],
-        [ [:big?],        TupleComputation[big?: big] ],
-        [ [:none],        TupleComputation[{}] ],
-      ].each do |(attrs,expected)|
-        context "on #{attrs}" do
-          let(:list){ attrs }
-
-          it{ should eq(expected) }
-        end
-      end
-    end
-
-    context 'when allbut' do
-      let(:allbut){ true }
-
-      [
-        [ [:big?, :who], TupleComputation[{}] ],
-        [ [:big?],       TupleComputation[who: who] ],
-        [ [:none],       TupleComputation[big?: big, who: who] ],
-      ].each do |(attrs,expected)|
-        context "on #{attrs}" do
-          let(:list){ attrs }
-
-          it{ should eq(expected) }
-        end
-      end
-    end
-
-  end
-end

data/spec/unit/alf-types/tuple_computation/test_to_attr_list.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation, "to_attr_list" do
-
-    it 'should return the correct list of attribute names' do
-      list = TupleComputation[
-        :big? => lambda{ status > 20 },
-        :who  => lambda{ "#{first} #{last}" }
-      ].to_attr_list
-      list.should be_a(AttrList)
-      list.to_a.to_set.should eq([:big?, :who].to_set)
-    end
-
-  end
-end

data/spec/unit/alf-types/tuple_computation/test_to_heading.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe TupleComputation, 'to_heading' do
-
-    let(:computation){
-      TupleComputation[
-        :big? => lambda{ status > 20 },
-        :who  => lambda{ "#{first} #{last}" },
-        :sub  => Relation::DUM
-      ]
-    }
-
-    subject{ computation.to_heading }
-
-    context 'with proper type inference' do
-      it{
-        pending "type inference on expressions not implemented" do
-          should eq(Heading[:big? => Boolean, :who => String])
-        end
-      }
-    end
-
-    context 'with currenttype inference' do
-      it{ should eq(Heading[:big? => Object, :who => Object, :sub => Relation::DUM_TYPE]) }
-    end
-
-  end
-end
-