alf 0.12.2 → 0.13.0

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

@@ -1,185 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Ordering do
-
-    describe "the class itself" do
-      let(:type){ Ordering }
-      def Ordering.exemplars
-        [
-          [],
-          [:a],
-          [[:a, :asc], [:b, :asc]]
-        ].map{|x| Ordering.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    describe "coerce" do
-
-      let(:expected){ Ordering.new([[:a, :asc], [:b, :asc]]) }
-
-      it "should work with an Ordering" do
-        key  = Ordering.coerce [:a, :b]
-        key.should eq(expected)
-      end
-
-      it "should work with an empty array" do
-        key  = Ordering.coerce []
-        key.should eq(Ordering.new([]))
-      end
-
-      it "should work with a normalized array" do
-        key = Ordering.coerce [[:a, :asc], [:b, :asc]]
-        key.should eq(expected)
-      end
-
-      it "should work with an array of AttrName" do
-        key = Ordering.coerce [:a, :b]
-        key.should eq(expected)
-      end
-
-      it "should work with an array of Strings" do
-        key = Ordering.coerce ["a", "b"]
-        key.should eq(expected)
-      end
-
-      it "should work with a single array with explicit asc/desc (1)" do
-        key = Ordering.coerce [:a, :asc]
-        key.should eq(Ordering.new([[:a, :asc]]))
-      end
-
-      it "should work with a single array with explicit asc/desc (2)" do
-        key = Ordering.coerce [:a, :asc, :b, :desc]
-        key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
-      end
-
-      it "should work with a single array with explicit asc/desc (3)" do
-        key = Ordering.coerce ["a", "asc", "b", "desc"]
-        key.should eq(Ordering.new([[:a, :asc], [:b, :desc]]))
-      end
-
-      it "should work with an AttrList" do
-        key = Ordering.coerce(AttrList.new([:a, :b]))
-        key.should eq(expected)
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ Ordering.from_argv(argv) }
-
-      describe "on an empty array" do
-        let(:argv){ [] }
-        it{ should eq(Ordering.new([])) }
-      end
-
-      describe "on a singleton" do
-        let(:argv){ ["hello"] }
-        it{ should eq(Ordering.new([[:hello, :asc]])) }
-      end
-
-      describe "on multiple strings without explit directions" do
-        let(:argv){ ["hello", "world"] }
-        it{ should eq(Ordering.new([[:hello, :asc], [:world, :asc]])) }
-      end
-
-      describe "on multiple strings with explit directions" do
-        let(:argv){ ["hello", "asc", "world", "desc"] }
-        it{ should eq(Ordering.new([[:hello, :asc], [:world, :desc]])) }
-      end
-
-    end # from_argv
-
-    describe "attributes" do
-
-      it 'should work on an empty ordering' do
-        Ordering.new([]).attributes.should eq([])
-      end
-
-      it 'should work on an singleton ordering' do
-        Ordering.new([[:a, :asc]]).attributes.should eq([:a])
-      end
-
-      it 'should work on an ordering' do
-        Ordering.new([[:a, :asc], [:b, :desc]]).attributes.should eq([:a, :b])
-      end
-
-    end # attributes
-
-    describe "compare" do
-
-      it "should work on a singleton ordering" do
-        key = Ordering.coerce [:a]
-        key.compare({:a => 1}, {:a => 2}).should == -1
-        key.compare({:a => 1}, {:a => 1}).should == 0
-        key.compare({:a => 2}, {:a => 1}).should == 1
-      end
-
-      it "should work on singleton when :desc" do
-        key = Ordering.coerce [[:a, :desc]]
-        key.compare({:a => 1}, {:a => 2}).should == 1
-        key.compare({:a => 1}, {:a => 1}).should == 0
-        key.compare({:a => 2}, {:a => 1}).should == -1
-      end
-
-      it "should work with multiple keys" do
-        key = Ordering.coerce [[:a, :asc], [:b, :desc]]
-        key.compare({:a => 1, :b => 1}, {:a => 0, :b => 1}).should == 1
-        key.compare({:a => -1, :b => 1}, {:a => 0, :b => 1}).should == -1
-        key.compare({:a => 0, :b => 1}, {:a => 0, :b => 0}).should == -1
-        key.compare({:a => 1, :b => 1}, {:a => 1, :b => 2}).should == 1
-        key.compare({:a => 1, :b => 1}, {:a => 1, :b => 1}).should == 0
-      end
-
-    end # compare
-
-    describe "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 # sorter
-
-    describe "+" do
-
-      subject{ Ordering.coerce(left) + right }
-      let(:expected){ Ordering.new([[:a, :asc], [:b, :desc]]) }
-
-      describe "with another Ordering" do
-        let(:left){ [:a] }
-        let(:right){ Ordering.new([[:b, :desc]]) }
-        it{ should eq(expected) }
-      end
-
-      describe "with  another array" do
-        let(:left){ [:a] }
-        let(:right){ [[:b, :desc]] }
-        it{ should eq(expected) }
-      end
-
-      describe "with  another array (2)" do
-        let(:left){ [:a] }
-        let(:right){ [:b, :desc] }
-        it{ should eq(expected) }
-      end
-
-    end # +
-
-    describe "to_attr_list" do
-
-      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 # "to_attr_list"
-
-  end # Ordering
-end # Alf

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

@@ -1,72 +0,0 @@
-require 'spec_helper'
-module Alf
-  describe Renaming do
-
-    describe "the class itself" do
-      let(:type){ Renaming }
-      def Renaming.exemplars
-        [
-          {},
-          {:old1 => :new1},
-          {:old1 => :new1, :old2 => :new2}
-        ].map{|x| Renaming.coerce(x)}
-      end
-      it_should_behave_like 'A valid type implementation'
-    end
-
-    describe "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 # coerce
-
-    describe "from_argv" do
-
-      subject{ Renaming.from_argv(argv) }
-
-      describe "from an empty Array" do
-        let(:argv){ [] }
-        it{ should eq(Renaming.new({})) }
-      end
-
-      describe "from an Array of two elements" do
-        let(:argv){ ["old", "new"] }
-        it{ should eq(Renaming.new(:old => :new)) }
-      end
-
-      describe "from an Array of four elements" do
-        let(:argv){ ["old", "new", "hello", "world"] }
-        it{ should eq(Renaming.new(:old => :new, :hello => :world)) }
-      end
-
-    end # from_argv
-
-    describe "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 # rename_tuple
-
-  end # Renaming
-end # Alf

data/spec/unit/alf-core/types/test_size.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-module Alf
-  module Types
-    describe Size do
-
-      describe "===" 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 # ===
-
-      describe "coerce" do
-
-        it 'should coerce strings correctly' do
-          Size.coerce("0").should eq(0)
-          Size.coerce("10").should eq(10)
-        end
-
-        it 'should raise ArgumentError on negative integers' do
-          lambda{ Size.coerce("-1") }.should raise_error(ArgumentError)
-        end
-
-        it 'should raise ArgumentError on non integers' do
-          lambda{ Size.coerce("hello") }.should raise_error(ArgumentError)
-        end
-
-      end # coerce
-
-      describe "from_argv" do
-
-        it 'should allow an empty array' do
-          Size.from_argv([]).should eq(0)
-        end
-
-        it 'should use the default value on empty array' do
-          Size.from_argv([], :default => 10).should eq(10)
-        end
-
-        it 'correctly coerce when non empty' do
-          Size.from_argv(["12"]).should eq(12)
-        end
-
-        it 'raise an ArgumentError on big array' do
-          lambda{ 
-            Size.from_argv(["12", "hello"])
-          }.should raise_error(ArgumentError)
-        end
-
-        it 'raise an ArgumentError on non coercable' do
-          lambda{ 
-            Size.from_argv(["hello"])
-          }.should raise_error(ArgumentError)
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,95 +0,0 @@
-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
-
-    describe "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.aggregations.values.all?{|v|
-            v.is_a?(Aggregator)
-          }.should be_true
-        }
-      end
-
-      describe "from an Array" do
-        let(:arg){ ["s", "sum{ qty }", "m", "max{ size }"] }
-        it{ should be_a(Summarization) }
-        specify{ 
-          ([:s, :m] & subject.aggregations.keys).should eq([:s, :m]) 
-          subject.aggregations.values.all?{|v|
-            v.is_a?(Aggregator)
-          }.should be_true
-        }
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ Summarization.from_argv(argv) }
-
-      describe "from an Array" do
-        let(:argv){ ["s", "sum{ qty }", "m", "max{ size }"] }
-        it{ should be_a(Summarization) }
-        specify{ 
-          ([:s, :m] & subject.aggregations.keys).should eq([:s, :m]) 
-          subject.aggregations.values.all?{|v|
-            v.is_a?(Aggregator)
-          }.should be_true
-        }
-      end
-
-    end # from argv
-
-    describe "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 # least
-
-    describe "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 # describe 
-
-    specify "least -> happens -> finalize" do
-      summ = Summarization.coerce(["s", "sum{ qty }", "m", "max{ size }"])
-      (x = summ.least).should eql(:s => 0, :m => nil)
-      (x = summ.happens(x, :qty => 10, :size => 12)).should eq(:s => 10, :m => 12)
-      (x = summ.happens(x, :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-core/types/test_tuple_computation.rb

@@ -1,96 +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(:handle){ Tools::TupleHandle.new.set(:who => "alf") }
-
-    describe "coerce" do
-
-      subject{ TupleComputation.coerce(arg).evaluate(handle) }
-
-      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 => 2,
-           :hello3 => lambda{ who } }
-        }
-        let(:expected){
-          {:hello => "alf", :hello2 => 2, :hello3 => "alf"}
-        }
-        it{ should eql(expected) }
-      end
-
-      describe "from a Hash with coercion" do
-        let(:arg){ 
-          {"hello" => "who", "hello2" => "2"}
-        }
-        let(:expected){
-          {:hello => "alf", :hello2 => 2}
-        }
-        it{ should eql(expected) }
-      end
-
-      describe "from an Array with coercions" do
-        let(:arg){ ["hello", "who", "hello2", "2"] }
-        let(:expected){
-          {:hello => "alf", :hello2 => 2}
-        }
-        it{ should eql(expected) }
-      end
-
-    end # coerce
-
-    describe "from_argv" do
-
-      subject{ TupleComputation.from_argv(argv).evaluate(handle) }
-
-      describe "from an Array with coercions" do
-        let(:argv){ ["hello", "who", "hello2", "2"] }
-        let(:expected){
-          {:hello => "alf", :hello2 => 2}
-        }
-        it{ should eql(expected) }
-      end
-
-    end # from_argv
-
-    describe "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 # "to_attr_list"
-
-  end
-end