alf-core 0.13.0

data/spec/unit/alf-types/ordering/test_sorter.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "sorter" do
+
+    let(:sorter){ Ordering.coerce([[:a, :desc]]).sorter }
+
+    it 'should sort correctly' do
+      [{:a => 2}, 
+       {:a => 7}, 
+       {:a => 1}].sort(&sorter).should eq([
+         {:a => 7}, {:a => 2}, {:a => 1}
+      ])
+    end
+
+  end # Ordering
+end # Alf

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Ordering, "to_attr_list" do
+
+    it 'should work on an empty ordering' do
+      Ordering.new([]).to_attr_list.should eq(AttrList.new [])
+    end
+
+    it 'should return the correct list of attribute names' do
+      Ordering.new([[:a, :asc], [:b, :desc]]).to_attr_list.should eq(AttrList[:a, :b])
+    end
+
+  end # Ordering
+end # Alf

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "coerce" do
+
+    subject{ Renaming.coerce(arg) }
+    let(:expected){ Renaming.new(:old1 => :new1, :old2 => :new2) }
+
+    describe "from a Renaming" do
+      let(:arg){ Renaming.new(:old1 => :new1, :old2 => :new2) }
+      it{ should eq(expected) }
+    end
+
+    describe "from a Hash" do
+      let(:arg){ {"old1" => "new1", "old2" => "new2"} }
+      it{ should eq(expected) }
+    end
+
+    describe "from an Array" do
+      let(:arg){ ["old1", "new1", "old2", "new2"] }
+      it{ should eq(expected) }
+    end
+
+  end # Renaming
+end # Alf

data/spec/unit/alf-types/renaming/test_complete.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "complete" do
+
+    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
+
+    subject{ renaming.complete(AttrList[:old, :blah]) }
+
+    let(:expected){ Renaming[:old => :new, :foo => :bar, :blah => :blah] }
+
+    it{ should eq(expected) }
+
+  end
+end

data/spec/unit/alf-types/renaming/test_invert.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "invert" do
+
+    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
+
+    let(:expected){ Renaming[:new => :old, :bar => :foo] }
+
+    subject{ renaming.invert }
+
+    it{ should eq(expected) }
+
+  end
+end

data/spec/unit/alf-types/renaming/test_rename_attr_list.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "rename_attr_list" do
+
+    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
+
+    let(:expected){ AttrList[:bar, :new, :name] }
+
+    subject{ renaming.rename_attr_list(attr_list) }
+
+    context 'on an attribute list' do
+      let(:attr_list){ AttrList[:foo, :old, :name] }
+
+      it{ should eq(expected) }
+    end
+
+    context 'on an Array of names' do
+      let(:attr_list){ [:foo, :old, :name] }
+
+      it{ should eq(expected) }
+    end
+
+  end
+end

data/spec/unit/alf-types/renaming/test_rename_tuple.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "rename_tuple" do
+
+    let(:r){ Renaming.coerce(["old", "new"]) } 
+
+    it 'should rename correctly' do
+      tuple    = {:old => :a, :other => :b}
+      expected = {:new => :a, :other => :b}
+      r.rename_tuple(tuple).should eq(expected)
+    end
+
+  end # Renaming
+end # Alf

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+module Alf
+  describe Renaming, "to_attr_list" do
+
+    let(:renaming){ Renaming[:old => :new, :foo => :bar] }
+
+    subject{ renaming.to_attr_list }
+
+    let(:expected){ AttrList[:old, :foo] }
+
+    it{ should eq(expected) }
+
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Size, "coerce" do
+
+      it 'should coerce strings correctly' do
+        Size.coerce("0").should eq(0)
+        Size.coerce("10").should eq(10)
+      end
+
+      it 'should raise TypeError on negative integers' do
+        lambda{ Size.coerce("-1") }.should raise_error(TypeError)
+      end
+
+      it 'should raise on non integers' do
+        lambda{
+          Size.coerce("hello")
+        }.should raise_error(TypeError)
+      end
+
+    end
+  end
+end

data/spec/unit/alf-types/size/test_triple_equal.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Alf
+  module Types
+    describe Size, "===" do
+
+      it 'should recognize 0' do
+        (Size === 0).should be_true
+      end
+
+      it 'should recognize any positive integer' do
+        (Size === 10).should be_true
+      end
+
+      it 'should not recognize negative integers' do
+        (Size === -1).should be_false
+      end
+
+      it 'should not recognize non integers' do
+        (Size === 10.0).should be_false
+        (Size === "12").should be_false
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  describe Summarization, "coerce" do
+
+    subject{ Summarization.coerce(arg) }
+
+    describe "from a Summarization" do
+      let(:arg){ Summarization.new(:s => Aggregator.sum{ qty }) }
+      it{ should eq(arg) }
+    end
+
+    describe "from a Hash" do
+      let(:arg){ { :s => "sum{ qty }", :m => Aggregator.max{ size } } }
+      it{ should be_a(Summarization) }
+      specify{ 
+        subject.to_hash.keys.to_set.should eq([:s, :m].to_set)
+        subject.to_hash.values.all?{|v| v.should be_a(Aggregator) }
+      }
+    end
+
+    describe "from an Array" do
+      let(:arg){ ["s", "sum{ qty }", "m", "max{ size }"] }
+      it{ should be_a(Summarization) }
+      specify{ 
+        subject.to_hash.keys.to_set.should eq([:s, :m].to_set)
+        subject.to_hash.values.all?{|v| v.should be_a(Aggregator) }
+      }
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'spec_helper'
+module Alf
+  describe Summarization, "least" do
+
+    it 'should invoke least on each aggregator' do
+      sum = Summarization.coerce(["s", "avg{ qty }", "m", "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

@@ -0,0 +1,15 @@
+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", "avg{ qty }", "m", "max{ size }"])
+      sum.summarize(rel).should eq({:s => 7.5, :m => 12})
+    end
+
+  end
+end

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+module Alf
+  describe Summarization do
+
+    describe "the class itself" do
+      let(:type){ Summarization }
+      def Summarization.exemplars
+        [
+          ["total", "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", "sum{ qty }", "m", "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