alf 0.10.1 → 0.11.0

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

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

@@ -0,0 +1,74 @@
+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/{types → alf-core/types}/test_summarization.rb

@@ -1,16 +1,26 @@
 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) }
@@ -20,7 +30,7 @@ module Alf
           }.should be_true
         }
       end
-      
+
       describe "from an Array" do
         let(:arg){ ["s", "sum{ qty }", "m", "max{ size }"] }
         it{ should be_a(Summarization) }
@@ -31,13 +41,13 @@ module Alf
           }.should be_true
         }
       end
-        
-    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) }
@@ -48,9 +58,31 @@ module Alf
           }.should be_true
         }
       end
-        
-    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)
@@ -58,6 +90,6 @@ module Alf
       (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/{types → alf-core/types}/test_tuple_computation.rb

@@ -2,11 +2,32 @@ 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") } 
@@ -23,7 +44,7 @@ module Alf
         }
         it{ should eql(expected) }
       end
-        
+
       describe "from a Hash with coercion" do
         let(:arg){ 
           {"hello" => "who", "hello2" => "2"}
@@ -33,7 +54,7 @@ module Alf
         }
         it{ should eql(expected) }
       end
-        
+
       describe "from an Array with coercions" do
         let(:arg){ ["hello", "who", "hello2", "2"] }
         let(:expected){
@@ -41,9 +62,11 @@ module Alf
         }
         it{ should eql(expected) }
       end
-    end
-    
+
+    end # coerce
+
     describe "from_argv" do
+
       subject{ TupleComputation.from_argv(argv).evaluate(handle) }
 
       describe "from an Array with coercions" do
@@ -53,8 +76,21 @@ module Alf
         }
         it{ should eql(expected) }
       end
-      
-    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
+end

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

@@ -0,0 +1,122 @@
+require 'spec_helper'
+module Alf
+  describe TupleExpression do
+
+    describe "the class itself" do
+      let(:type){ TupleExpression }
+      def TupleExpression.exemplars
+        [
+          "10",
+          "status > 10",
+        ].map{|x| TupleExpression.coerce(x)}
+      end
+      it_should_behave_like 'A valid type implementation'
+    end
+
+    it "should include a valid example" do
+      expr = TupleExpression["status * 10"]
+      expr.call(:status => 20).should eq(200)
+    end
+
+    let(:handle) {
+      Tools::TupleHandle.new.set(:status => 10)
+    }
+
+    describe "coerce" do
+
+      subject{ TupleExpression.coerce(arg) }
+
+      describe "with nil" do
+        let(:arg){ nil }
+        specify{ lambda{ subject }.should raise_error(ArgumentError) }
+      end
+
+      describe "with a String" do
+        let(:arg){ "true" }
+        it { should be_a(TupleExpression) }
+        specify{ 
+          subject.evaluate(handle).should eql(true) 
+          subject.source.should eq("true")
+        }
+      end
+
+      describe "with a Symbol" do
+        let(:arg){ :status }
+        it { should be_a(TupleExpression) }
+        specify{ 
+          subject.evaluate(handle).should eql(10) 
+          subject.source.should eq(:status)
+        }
+      end
+
+      describe "with a Proc" do
+        let(:arg){ lambda{ :hello } }
+        it { should be_a(TupleExpression) }
+        specify{ 
+          subject.evaluate(handle).should eql(:hello) 
+          subject.source.should be_nil
+        }
+      end
+
+    end # coerce
+
+    describe "from_argv" do
+
+      subject{ TupleExpression.from_argv(argv) }
+
+      describe "with a String (1)" do
+        let(:argv){ %w{true} }
+        it { should be_a(TupleExpression) }
+        specify{ 
+          subject.evaluate(handle).should eql(true) 
+          subject.source.should eq("true")
+        }
+      end
+
+      describe "with a String (2)" do
+        let(:argv){ ["status > 10"] }
+        it { should be_a(TupleExpression) }
+        specify{ 
+          subject.evaluate(handle).should eql(false) 
+          subject.source.should eq("status > 10")
+        }
+      end
+
+      describe "with two String" do
+        let(:argv){ %w{hello world} }
+        specify{ lambda{subject}.should raise_error(ArgumentError) }
+      end
+
+    end # from_argv
+
+    describe 'call' do
+      let(:expr){ TupleExpression["status > 10"] }
+
+      it 'should build its handle correctly' do
+        expr.call(:status => 20).should be_true
+        expr.call(:status => 5).should be_false
+      end
+
+      it 'should be aliased ad []' do
+        expr[:status => 20].should be_true
+        expr[:status => 5].should be_false
+      end
+
+    end # call
+
+    describe 'to_ruby_literal' do
+
+      it 'should work when code is known' do
+        expr = TupleExpression["status > 10"]
+        expr.to_ruby_literal.should eq('Alf::TupleExpression["status > 10"]')
+      end
+
+      it 'should raise a NotImplementedError if no source code' do
+        expr = TupleExpression[lambda{status > 10}]
+        lambda{ expr.to_ruby_literal }.should raise_error(NotImplementedError)
+      end
+
+    end # to_ruby_literal
+
+  end # TupleExpression
+end # Alf

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

@@ -2,78 +2,107 @@ require 'spec_helper'
 module Alf
   describe TuplePredicate do
 
+    describe "the class itself" do
+      let(:type){ TuplePredicate }
+      def TuplePredicate.exemplars
+        [
+          "status > 10",
+          {:status => 10}
+        ].map{|x| TuplePredicate.coerce(x)}
+      end
+      it_should_behave_like 'A valid type implementation'
+    end
+
     let(:handle){ Tools::TupleHandle.new.set(:status => 10) }
-      
+
     describe "coerce" do
-      subject{ TuplePredicate.coerce(arg).evaluate(handle) }
-      
+
+      let(:pred){ TuplePredicate.coerce(arg) }
+      before{ pred.should be_a(TuplePredicate) }
+      subject{ pred.evaluate(handle) }
+
       describe "from TuplePredicate" do
         let(:arg){ TuplePredicate.new(lambda{ status == 10 }) }
         it{ should eql(true) }
       end
-      
+
       describe "from true" do
         let(:arg){ true }
         it{ should eql(true) }
       end
-      
+
       describe "from false" do
         let(:arg){ false }
         it{ should eql(false) }
       end
-        
+
       describe "from Proc" do
         let(:arg){ lambda{ status == 10 } }
         it{ should eql(true) }
       end
-      
+
       describe "from String" do
         let(:arg){ "status == 10" }
         it{ should eql(true) }
       end
-      
+
       describe "from Symbol" do
         let(:arg){ :status }
         it{ should eql(10) }
       end
-      
+
       describe "from Hash without coercion" do
         let(:arg){ {:status => 10} }
         it{ should eql(true) }
       end
-      
+
       describe "from Hash with coercion" do
         let(:arg){ {"status" => "10"} }
         it{ should eql(true) }
       end
-      
+
       describe "from a singleton Array" do
         let(:arg){ ["status == 10"] }
         it{ should eql(true) }
       end
-      
+
       describe "from an Array with coercion" do
         let(:arg){ ["status", "10"] }
         it{ should eql(true) }
       end
-      
-    end
-    
+
+    end # coerce
+
     describe "from_argv" do
+
       subject{ TuplePredicate.from_argv(argv).evaluate(handle) }
       
-      
       describe "from a singleton Array" do
         let(:argv){ ["status == 10"] }
         it{ should eql(true) }
       end
-      
+
       describe "from an Array with coercion" do
         let(:argv){ ["status", "10"] }
         it{ should eql(true) }
       end
-      
-    end
-     
-  end
-end
+
+    end # from_argv
+
+    describe 'to_ruby_literal' do
+
+      it 'should work when code is known' do
+        expr = TuplePredicate["status > 10"]
+        expr.should be_a(TuplePredicate)
+        expr.to_ruby_literal.should eq('Alf::TuplePredicate["status > 10"]')
+      end
+
+      it 'should raise a NotImplementedError if no source code' do
+        expr = TuplePredicate[lambda{status > 10}]
+        lambda{ expr.to_ruby_literal }.should raise_error(NotImplementedError)
+      end
+
+    end # to_ruby_literal
+
+  end # TuplePredicate
+end # Alf

data/spec/unit/{csv → alf-csv}/test_renderer.rb

@@ -34,7 +34,7 @@ module Alf
         end
       end
       
-      describe "with options" do
+      describe "with options", :hash_ordering => true do
         let(:input){ 
           [{:size => 10, :name => "blambeau"}, {:size => 20, :name => "mmathieu"}]
         }

data/spec/unit/alf-engine/compact/test_set.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compact::Set do
+
+      it 'should work on an empty operand' do
+        Compact::Set.new([]).to_a.should eq([])
+      end
+
+      it 'should work when no duplicate is present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact::Set.new(rel).to_set.should eq(rel.to_set)
+      end
+
+      it 'should work when duplicates are present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"},
+          {:name => "Jones"},
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact::Set.new(rel).to_set.should eq(exp.to_set)
+      end
+
+    end
+  end # module Engine
+end # module Alf

data/spec/unit/alf-engine/compact/test_uniq.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+module Alf
+  module Engine
+    describe Compact::Uniq do
+
+      it 'should work on an empty operand' do
+        Compact::Uniq.new([]).to_a.should eq([])
+      end
+
+      it 'should work when no duplicate is present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact::Uniq.new(rel).to_a.should eq(rel)
+      end
+
+      it 'should work when duplicates are present' do
+        rel = [
+          {:name => "Jones"},
+          {:name => "Smith"},
+          {:name => "Jones"},
+        ]
+        exp = [
+          {:name => "Jones"},
+          {:name => "Smith"}
+        ]
+        Compact::Uniq.new(rel).to_a.should eq(exp)
+      end
+
+    end
+  end # module Engine
+end # module Alf