alf 0.10.1 → 0.11.0

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

@@ -0,0 +1,188 @@
+require 'spec_helper'
+module Alf
+  describe AttrList do
+
+    describe "the class itself" do
+      let(:type){ AttrList }
+      def AttrList.exemplars
+        [
+          [],
+          [:a],
+          [:a, :b]
+        ].map{|arg| AttrList.coerce(arg) }
+      end
+      it_should_behave_like 'A valid type implementation'
+    end
+
+    describe "coerce" do
+
+      subject{ AttrList.coerce(arg) }
+
+      describe "when passed a AttrList" do
+        let(:arg){ [:a, :b] } 
+        it{ should eq(AttrList.new(arg)) }
+      end
+
+      describe "when passed an Ordering" do
+        let(:arg){ Ordering.new [[:a, :asc], [:b, :asc]] }
+        it{ should eq(AttrList.new([:a, :b])) }
+      end
+
+      describe "when passed a TupleComputation" do
+        let(:arg){ TupleComputation[:a => 12, :b => "Smith"] }
+        specify{ 
+          subject.should be_a(AttrList) 
+          subject.to_a.to_set.should eq([:a, :b].to_set)
+        }
+      end
+
+      describe "when passed an array" do
+        let(:arg){ [:a, :b] }
+        it{ should eq(AttrList.new([:a, :b])) }
+      end
+
+      describe "when passed an unrecognized argument" do
+        let(:arg){ :not_recognized }
+        specify{
+          lambda{ subject }.should raise_error(ArgumentError)
+        }
+      end
+
+    end # coerce
+
+    describe "[]" do
+
+      it 'should allow an empty list' do
+        AttrList[].should eq(AttrList.new([]))
+      end
+
+      it 'should allow an non-empty list' do
+        AttrList[:name, :city].should eq(AttrList.new([:name, :city]))
+      end
+
+    end # []
+
+    describe "from_argv" do
+
+      subject{ AttrList.from_argv(argv) }
+
+      describe "on an empty array" do
+        let(:argv){ [] }
+        it{ should eq(AttrList.new([])) }
+      end
+
+      describe "on a singleton" do
+        let(:argv){ ["hello"] }
+        it{ should eq(AttrList.new([:hello])) }
+      end
+
+      describe "on multiple strings" do
+        let(:argv){ ["hello", "world"] }
+        it{ should eq(AttrList.new([:hello, :world])) }
+      end
+
+      describe "when passed an unrecognized argument" do
+        let(:argv){ :not_recognized }
+        specify{
+          lambda{ subject }.should raise_error(ArgumentError)
+        }
+      end
+
+    end # from_argv
+
+    describe "to_ordering" do
+
+      describe "without direction" do
+        subject{ AttrList.coerce(attrs).to_ordering }
+        let(:attrs){ [:a, :b] }
+        it{ should eq(Ordering.new [[:a, :asc], [:b, :asc]])}
+      end
+
+      describe "with a direction" do
+        subject{ AttrList.coerce(attrs).to_ordering(direction) }
+        let(:attrs){ [:a, :b] }
+        let(:direction){ :desc }
+        it{ should eq(Ordering.new [[:a, :desc], [:b, :desc]])}
+      end
+
+    end # to_ordering
+
+    describe "split_tuple" do 
+
+      let(:key){ AttrList.new [:a, :b] }
+      let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+
+      describe "when used without allbut" do
+        subject{ key.split_tuple(tuple) }
+        it{ should eq([{:a => 1, :b => 2}, {:c => 3}]) }
+      end
+
+      describe "when used with allbut set to true" do
+        subject{ key.split_tuple(tuple, true) }
+        it{ should eq([{:c => 3}, {:a => 1, :b => 2}]) }
+      end
+
+      describe "when used with allbut set to false" do
+        subject{ key.split_tuple(tuple, false) }
+        it{ should eq([{:a => 1, :b => 2}, {:c => 3}]) }
+      end
+
+      specify "the documentation example" do
+        list = AttrList.new([:name])
+        tuple = {:name => "Jones", :city => "London"}
+        list.split_tuple(tuple).should eq([{:name => "Jones"}, {:city => "London"}])
+        list.split_tuple(tuple, true).should eq([{:city => "London"}, {:name => "Jones"}])
+      end
+
+    end # split
+
+    describe "project_tuple" do 
+
+      let(:key){ AttrList.new [:a, :b] }
+      let(:tuple){ {:a => 1, :b => 2, :c => 3} }
+
+      describe "when used without allbut" do
+        subject{ key.project_tuple(tuple) }
+        it{ should eq({:a => 1, :b => 2}) }
+      end
+
+      describe "when used with allbut set to true" do
+        subject{ key.project_tuple(tuple, true) }
+        it{ should eq({:c => 3}) }
+      end
+
+      describe "when used without allbut set to false" do
+        subject{ key.project_tuple(tuple, false) }
+        it{ should eq({:a => 1, :b => 2}) }
+      end
+
+      specify "the documentation example" do
+        list = AttrList.new([:name])
+        tuple = {:name => "Jones", :city => "London"}
+        list.project_tuple(tuple).should eq({:name => "Jones"})
+        list.project_tuple(tuple, true).should eq({:city => "London"})
+      end
+
+    end # project
+
+    it 'should to_a' do
+      AttrList[:a, :b].to_a.should eq([:a, :b])
+      AttrList[].to_a.should eq([])
+    end
+
+    it "should define a value" do
+      l1 = AttrList.new [:a, :b]
+      l2 = AttrList.new [:a, :b]
+      l3 = AttrList.new [:a]
+
+      l1.should == l2
+      l1.should eq(l2)
+
+      l1.should_not == l3
+      l1.should_not eq(l3)
+
+      {l1 => 1, l2 => 2}.size.should eq(1)
+    end
+
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'spec_helper'
+module Alf
+  describe AttrName do
+
+    describe "===" do
+
+      it "should allow normal names" do
+        (AttrName === :city).should be_true
+      end
+
+      it "should allow underscores" do
+        (AttrName === :my_city).should be_true
+      end
+
+      it "should allow numbers" do
+        (AttrName === :city2).should be_true
+      end
+
+      it "should allow question marks and bang" do
+        (AttrName === :big?).should be_true
+        (AttrName === :big!).should be_true
+      end
+
+      it "should not allow strange attribute names" do
+        (AttrName === "$$$".to_sym).should be_false
+      end
+
+    end # ===
+
+    describe "coerce" do
+
+      it 'should work on valid attribute names' do
+        AttrName.coerce("city").should eq(:city)
+        AttrName.coerce(:big?).should eq(:big?)
+      end
+
+      it 'should be aliased as []' do
+        AttrName["city"].should eq(:city)
+      end
+
+      it 'should raise ArgumentError otherwise' do
+        lambda{ AttrName["!123"] }.should raise_error(ArgumentError)
+      end
+
+    end # coerce
+
+    describe "from_argv" do
+
+      subject{ AttrName.from_argv(argv, opts) }
+
+      describe "with a String" do
+        let(:argv){ %w{hello} }
+        let(:opts) {{}}
+        it{ should eq(:hello) }
+      end
+
+      describe "with nothing but a default" do
+        let(:argv){ %w{} }
+        let(:opts){ {:default => :hello} }
+        it{ should eq(:hello) }
+      end
+
+      describe "with nothing and no default" do
+        let(:argv){ %w{} }
+        let(:opts){ {} }
+        specify{ lambda{subject}.should raise_error(ArgumentError) }
+      end
+
+      describe "with more than one string" do
+        let(:argv){ %w{hello world} }
+        let(:opts){ {} }
+        specify{ lambda{subject}.should raise_error(ArgumentError) }
+      end
+
+    end # from_argv
+
+  end
+end

data/spec/unit/{types/test_attr_name.rb → alf-core/types/test_boolean.rb}

@@ -1,42 +1,32 @@
 require 'spec_helper'
 module Alf
-  describe AttrName do
-    
-    it "should allow normal names" do
-      (AttrName === :city).should be_true
-    end
-    
-    it "should allow underscores" do
-      (AttrName === :my_city).should be_true
-    end
-    
-    it "should allow numbers" do
-      (AttrName === :city2).should be_true
-    end
-    
-    it "should not allow strange attribute names" do
-      (AttrName === "$$$".to_sym).should be_false
-    end
-    
+  describe Boolean do
+
     describe "from_argv" do
-      
-      subject{ AttrName.from_argv(argv, opts) }
-      
+
+      subject{ Boolean.from_argv(argv, opts) }
+
       describe "with a String" do
-        let(:argv){ %w{hello} }
+        let(:argv){ %w{true} }
         let(:opts) {{}}
-        it{ should eq(:hello) }
+        it{ should eq(true) }
       end
 
       describe "with nothing but a default" do
         let(:argv){ %w{} }
-        let(:opts){ {:default => :hello} }
-        it{ should eq(:hello) }
+        let(:opts){ {:default => true} }
+        it{ should eq(true) }
       end
 
       describe "with nothing and no default" do
         let(:argv){ %w{} }
         let(:opts){ {} }
+        it{ should eq(false) }
+      end
+
+      describe "with an invalid string" do
+        let(:argv){ %w{hello} }
+        let(:opts){ {} }
         specify{ lambda{subject}.should raise_error(ArgumentError) }
       end
 
@@ -45,8 +35,8 @@ module Alf
         let(:opts){ {} }
         specify{ lambda{subject}.should raise_error(ArgumentError) }
       end
-      
-    end
-    
+
+    end # from_argv
+
   end
 end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  describe Types do
+    include Types
+
+    describe "common_super_type" do
+
+      it 'should work on same types' do
+        common_super_type(String, String).should eq(String)
+      end
+
+      it 'should work with related types' do
+        common_super_type(Fixnum, Integer).should eq(Integer)
+        common_super_type(Fixnum, Float).should eq(Numeric)
+      end
+
+      it 'should work with un related types' do
+        common_super_type(Fixnum, String).should eq(Object)
+      end
+
+    end
+
+  end # describe Types
+end # module Alf

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

@@ -0,0 +1,146 @@
+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 "coerce" do
+
+      it "should work with a heading" do
+        Heading.coerce(h0).should eq(h0)
+        Heading.coerce(h1).should eq(h1)
+      end
+
+      it "should work with hashes" do
+        Heading.coerce(:name => String).should eq(h1)
+        Heading.coerce("name" => "String").should eq(h1)
+        Heading.coerce({}).should eq(h0)
+      end
+
+      it "should work with arrays" do
+        Heading.coerce([]).should eq(h0)
+        Heading.coerce(["name", "String"]).should eq(h1)
+      end
+
+      specify "should raise ArgumentError on error" do
+        lambda{ Heading.coerce(true) }.should raise_error(ArgumentError)
+      end
+
+    end # coerce
+
+    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(ArgumentError)
+      end
+
+    end # []
+
+    describe "from_argv" do
+
+      it "should work with an array of strings" do
+        Heading.from_argv(["name", "String"]).should eq(h1)
+      end
+
+    end
+
+    describe "cardinality" do
+
+      it "should return the number of pairs" do
+        h0.cardinality.should eq(0)
+        h1.cardinality.should eq(1)
+        h2.cardinality.should eq(2)
+      end
+
+      it 'should be aliased as count' do
+        [h0, h1, h2].all?{|h| h.cardinality == h.count}.should be_true
+      end
+
+      it 'should be aliased as size' do
+        [h0, h1, h2].all?{|h| h.cardinality == h.size}.should be_true
+      end
+
+    end # cardinality, count, size
+
+    describe "union" do
+
+      let(:h_name){ Heading[:name => String] }
+      let(:h_city){ Heading[:city => String] }
+
+      it "should work on empty headings" do
+        Heading::EMPTY.union(Heading::EMPTY).should eq(Heading::EMPTY)
+      end
+
+      it "should work with disjoint headings" do
+        h_name.union(h_city).should eq(Heading[:name => String, :city => String])
+      end
+
+      it "should be aliased as +" do
+        (h_name + h_city).should eq(Heading[:name => String, :city => String])
+      end
+
+      it "should work compute supertype on non-disjoint headings" do
+        h1 = Heading[:age => Fixnum, :name => String]
+        h2 = Heading[:age => Integer]
+        (h1 + h2).should eq(Heading[:age => Integer, :name => String])
+      end
+
+      it "should be aliased as join" do
+        h1 = Heading[:age => Fixnum, :name => String]
+        h2 = Heading[:age => Integer]
+        h1.join(h2).should eq(Heading[:age => Integer, :name => String])
+      end
+
+    end # union
+
+    it "should implement a to_h method" do
+      h0.to_h.should eq({})
+      h1.to_h.should eq(:name => String)
+      h2.to_h.should eq(:name => String, :price => Float)
+    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-core/types/test_ordering.rb

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