alf 0.9.3 → 0.10.0

data/spec/unit/operator/relational/join/test_hash_based.rb

@@ -25,7 +25,7 @@ module Alf
       subject{ operator.to_a }
   
       describe "when applied on both candidate keys" do
-        before{ operator.datasets = [suppliers, statuses] }
+        before{ operator.pipe [suppliers, statuses] }
         let(:expected){[
           {:sid => 'S1', :city => 'London', :status => 20},
           {:sid => 'S2', :city => 'Paris', :status => 10},
@@ -41,17 +41,17 @@ module Alf
           {:sid => 'S3', :city => 'Paris',  :country => 'France'}
         ]}
         describe "on one way" do
-          before{ operator.datasets = [suppliers, countries] }
+          before{ operator.pipe [suppliers, countries] }
           it { should == expected }
         end
         describe "on the other way around" do
-          before{ operator.datasets = [countries, suppliers] }
+          before{ operator.pipe [countries, suppliers] }
           it { should == expected }
         end
       end
       
       describe "when no attributes are in common" do
-        before{ operator.datasets = [statuses, countries] }
+        before{ operator.pipe [statuses, countries] }
         let(:expected){
           statuses.collect{|s| countries.collect{|c| c.merge(s)}}.flatten
         }

data/spec/unit/operator/relational/matching/test_hash_based.rb

@@ -25,33 +25,33 @@ module Alf
       subject{ operator.to_rel }
   
       describe "when applied on both candidate keys" do
-        before{ operator.datasets = [suppliers, statuses] }
+        before{ operator.pipe  [suppliers, statuses] }
         it { should eq(suppliers) }
       end
       
       describe "when applied on a typical foreign key" do
         describe "on one way" do
-          before{ operator.datasets = [suppliers, countries] }
+          before{ operator.pipe  [suppliers, countries] }
           it { should eq(suppliers) }
         end
         describe "on the other way around" do
-          before{ operator.datasets = [countries, suppliers] }
+          before{ operator.pipe  [countries, suppliers] }
           it { should eq(countries.restrict(lambda{ city != 'Bruxelles' })) }
         end
       end
       
       describe "when no attributes are in common" do
-        before{ operator.datasets = [statuses, countries] }
+        before{ operator.pipe  [statuses, countries] }
         it { should eq(statuses) }
       end
       
       describe "against DEE" do
-        before{ operator.datasets = [suppliers, Relation::DEE] }
+        before{ operator.pipe  [suppliers, Relation::DEE] }
         it { should eq(suppliers) }
       end
       
       describe "against DUM" do
-        before{ operator.datasets = [suppliers, Relation::DUM] }
+        before{ operator.pipe  [suppliers, Relation::DUM] }
         it { should eq(Relation::DUM) }
       end
 

data/spec/unit/operator/relational/not_matching/test_hash_based.rb

@@ -13,22 +13,22 @@ module Alf
       subject{ operator.to_rel }
 
       describe "when applied on itself" do
-        before{ operator.datasets = [suppliers, suppliers] }
+        before{ operator.pipe [suppliers, suppliers] }
         it { should eq(suppliers.minus(suppliers)) }
       end
   
       describe "when applied against a subset" do
-        before{ operator.datasets = [suppliers, Alf::Relation[{:sid => 'S1'}]] }
+        before{ operator.pipe [suppliers, Alf::Relation[{:sid => 'S1'}]] }
         it { should eq(suppliers.restrict(lambda{ sid != 'S1' })) }
       end
       
       describe "against DEE" do
-        before{ operator.datasets = [suppliers, Relation::DEE] }
+        before{ operator.pipe [suppliers, Relation::DEE] }
         it { should eq(Relation::DUM) }
       end
       
       describe "against DUM" do
-        before{ operator.datasets = [suppliers, Relation::DUM] }
+        before{ operator.pipe [suppliers, Relation::DUM] }
         it { should eq(suppliers) }
       end
 

data/spec/unit/operator/relational/summarize/test_hash_based.rb

@@ -16,23 +16,27 @@ module Alf
         {:a => "via_reader", :time_sum => 6, :time_max => 4},
       ]}
   
-      let(:aggs){{:time_sum => Aggregator.sum(:time),
-                  :time_max => Aggregator.max(:time)}} 
-      let(:operator){ Summarize::HashBased.new(by_key, aggs) }
+      let(:aggs){Summarization.new(
+        :time_sum => Aggregator.sum{ time },
+        :time_max => Aggregator.max{ time }
+      )} 
+      let(:operator){ Summarize::HashBased.new(by_key, allbut, aggs) }
 
       before{ operator.pipe(input) }
       subject{ operator.to_a.sort{|t1,t2| t1[:a] <=> t2[:a]} }
   
       describe "when allbut is not set" do
-        let(:by_key){ Tools::ProjectionKey.new([:a], false) }
+        let(:by_key){ AttrList.new([:a]) }
+        let(:allbut){ false }
         it { should == expected }
       end
   
       describe "when allbut is set" do
-        let(:by_key){ Tools::ProjectionKey.new([:time], true) }
+        let(:by_key){ AttrList.new([:time]) }
+        let(:allbut){ true }
         it { should == expected }
       end
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/summarize/test_sort_based.rb

@@ -16,16 +16,27 @@ module Alf
         {:a => "via_reader", :time_sum => 6, :time_max => 4},
       ]}
   
-      let(:by_key){ Tools::ProjectionKey.new([:a],false) }
-      let(:aggs){{:time_sum => Aggregator.sum(:time),
-                  :time_max => Aggregator.max(:time)}} 
-      let(:operator){ Summarize::SortBased.new(by_key, aggs) }
+      let(:aggs){Summarization.new(
+        :time_sum => Aggregator.sum{ time },
+        :time_max => Aggregator.max{ time }
+      )} 
+      let(:operator){ Summarize::SortBased.new(by_key, allbut, aggs) }
   
       before{ operator.pipe(input) }
-      subject{ operator.to_a }
+      subject{ operator.to_a.sort{|t1,t2| t1[:a] <=> t2[:a]} }
   
-      it { should == expected }
+      describe "when allbut is not set" do
+        let(:by_key){ AttrList.new([:a]) }
+        let(:allbut){ false }
+        it { should == expected }
+      end
+  
+      describe "when allbut is set" do
+        let(:by_key){ AttrList.new([:time]) }
+        let(:allbut){ true }
+        it { should == expected }
+      end
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/test_group.rb

@@ -13,9 +13,9 @@ module Alf
       ]}
   
       let(:expected) {[
-        {:a => "via_method", :as => rel({:time => 1, :b => "b"}, 
-                                        {:time => 2, :b => "b"})},
-        {:a => "via_reader", :as => rel({:time => 3, :b => "b"})},
+        {:a => "via_method", :as => Alf::Relation[{:time => 1, :b => "b"}, 
+                                                  {:time => 2, :b => "b"}]},
+        {:a => "via_reader", :as => Alf::Relation[{:time => 3, :b => "b"}]},
       ]}
   
       subject{ operator.to_a.sort{|k1,k2| k1[:a] <=> k2[:a]} }
@@ -23,7 +23,7 @@ module Alf
       describe "without --allbut" do
   
         describe "when factored with commandline args" do
-          let(:operator){ Group.run(["--", "time", "b", "as"]) }
+          let(:operator){ Group.run(["--", "time", "b", "--", "as"]) }
           before{ operator.pipe(input) }
           it { should == expected }
         end
@@ -38,13 +38,13 @@ module Alf
       describe "with --allbut" do
           
         describe "when factored with commandline args" do
-          let(:operator){ Group.run(["--","a", "as"]) }
-          before{ operator.allbut = true; operator.pipe(input) }
+          let(:operator){ Group.run(["--allbut", "--","a", "--", "as"]) }
+          before{ operator.pipe(input) }
           it { should == expected }
         end
     
         describe "when factored with Lispy" do
-          let(:operator){ Lispy.group(input, [:a], :as, true) }
+          let(:operator){ Lispy.group(input, [:a], :as, :allbut => true) }
           it { should == expected }
         end
         
@@ -52,4 +52,4 @@ module Alf
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/test_intersect.rb

@@ -26,12 +26,12 @@ module Alf
       subject{ operator.to_a }
   
       describe "when applied on the same operand twice" do
-        before{ operator.datasets = [left, left] }
+        before{ operator.pipe [left, left] }
         it { should == left }
       end
       
       describe "when applied on operands sharing tuples" do
-        before{ operator.datasets = [left, right] }
+        before{ operator.pipe [left, right] }
         let(:expected) {[
           {:sid => 'S1', :city => 'London'},
           {:sid => 'S2', :city => 'Paris'},
@@ -40,7 +40,7 @@ module Alf
       end
     
       describe "when applied on disjoint operands" do
-        before{ operator.datasets = [left, disjoint] }
+        before{ operator.pipe [left, disjoint] }
         it { should be_empty }
       end
       

data/spec/unit/operator/relational/test_minus.rb

@@ -26,12 +26,12 @@ module Alf
       subject{ operator.to_a }
   
       describe "when applied on the same operand twice" do
-        before{ operator.datasets = [left, left] }
+        before{ operator.pipe [left, left] }
         it { should be_empty }
       end
       
       describe "when applied on operands sharing tuples" do
-        before{ operator.datasets = [left, right] }
+        before{ operator.pipe [left, right] }
         let(:expected) {[
           {:sid => 'S3', :city => 'Paris'}
         ]}
@@ -39,7 +39,7 @@ module Alf
       end
     
       describe "when applied on disjoint operands" do
-        before{ operator.datasets = [left, disjoint] }
+        before{ operator.pipe [left, disjoint] }
         it { should == left }
       end
       

data/spec/unit/operator/relational/test_project.rb

@@ -38,7 +38,12 @@ module Alf
           it { should == expected } 
         end
   
-        describe "and factored with Lispy" do
+        describe "and factored with Lispy#project" do
+          let(:operator){ Lispy.project(input, [:a], :allbut => true) }
+          it { should == expected } 
+        end
+  
+        describe "and factored with Lispy#allbut" do
           let(:operator){ Lispy.allbut(input, [:a]) }
           it { should == expected } 
         end
@@ -58,8 +63,13 @@ module Alf
           it { should == [] } 
         end
         
+        describe "when allbut is used" do
+          let(:operator){ Lispy.project(input, [:a, :b], :allbut => true) }
+          it { should == expected } 
+        end
+        
       end # all attributes projected
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/test_quota.rb

@@ -25,20 +25,19 @@ module Alf
       subject{ operator.to_a }
   
       describe "When factored with commandline args" do
-        let(:opts){ ['--by=a', "--order=time"] }
-        let(:aggs){ ["time_sum", "sum(:time)", "time_max", "max(:time)"] }
-        let(:operator){ Quota.run(opts + ["--"] + aggs) }
+        let(:aggs){ ["--", "a", "--", "time", "--", "time_sum", "sum{ time }", "time_max", "max{ time }"] }
+        let(:operator){ Quota.run(aggs) }
         before{ operator.pipe(input) }
         it { should == expected }
       end
   
       describe "When factored with Lispy" do
-        let(:aggs){{:time_sum => Aggregator.sum(:time),
-                    :time_max => Aggregator.max(:time)}} 
+        let(:aggs){{:time_sum => Aggregator.sum{ time },
+                    :time_max => Aggregator.max{ time }}} 
         let(:operator){ Lispy.quota(input, [:a], [:time], aggs) }
         it { should == expected }
       end
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/test_summarize.rb

@@ -19,18 +19,17 @@ module Alf
         {:a => "via_reader", :time_sum => 6, :time_max => 4, :time_avg => 6.0/2},
       ]}
   
-      let(:aggs){{:time_sum => Aggregator.sum(:time),
-                  :time_max => Aggregator.max(:time),
-                  :time_avg => Aggregator.avg(:time)}} 
+      let(:aggs){{:time_sum => Aggregator.sum{ time },
+                  :time_max => Aggregator.max{ time },
+                  :time_avg => Aggregator.avg{ time }}} 
 
       subject{ operator.to_a.sort{|t1,t2| t1[:a] <=> t2[:a]} }
   
       describe "without allbut" do
         
         describe "When factored with commandline args" do
-          let(:opts){ ["--by=a"] }
-          let(:aggs){ ["time_sum", "sum(:time)", "time_max", "max(:time)", "time_avg", "avg(:time)"] }
-          let(:operator){ Summarize.run(opts + ["--"] +aggs) }
+          let(:aggs){ ["--", "a", "--", "time_sum", "sum{ time }", "time_max", "max{ time }", "time_avg", "avg{ time }"] }
+          let(:operator){ Summarize.run(aggs) }
           before{ operator.pipe(input) }
           it { should == expected }
         end
@@ -45,15 +44,14 @@ module Alf
       describe "with allbut" do
         
         describe "When factored with commandline args" do
-          let(:opts){ ["--by=time", "--allbut"] }
-          let(:aggs){ ["time_sum", "sum(:time)", "time_max", "max(:time)", "time_avg", "avg(:time)"] }
-          let(:operator){ Summarize.run(opts + ["--"] + aggs) }
+          let(:aggs){ ["--allbut", "--", "time", "--", "time_sum", "sum{ time }", "time_max", "max{ time }", "time_avg", "avg{ time }"] }
+          let(:operator){ Summarize.run(aggs) }
           before{ operator.pipe(input) }
           it { should == expected }
         end
     
         describe "When factored with Lispy" do
-          let(:operator){ Lispy.summarize(input, [:time], aggs, true) }
+          let(:operator){ Lispy.summarize(input, [:time], aggs, :allbut => true) }
           it { should == expected }
         end
 
@@ -61,4 +59,4 @@ module Alf
   
     end 
   end
-end
+end

data/spec/unit/operator/relational/test_union.rb

@@ -21,7 +21,7 @@ module Alf
       subject{ operator.to_a }
   
       describe "when applied on non disjoint sets" do
-        before{ operator.datasets = [left, right] }
+        before{ operator.pipe [left, right] }
         let(:expected){[
           {:city => 'London'},
           {:city => 'Paris'},

data/spec/unit/operator/relational/test_wrap.rb

@@ -17,7 +17,7 @@ module Alf
       subject{ operator.to_a }
   
       describe "when factored with commandline args" do
-        let(:operator){ Wrap.run(["--", "a", "b", "wraped"]) }
+        let(:operator){ Wrap.run(["--", "a", "b", "--", "wraped"]) }
         before{ operator.pipe(input) }
         it { should == expected }
       end

data/spec/unit/operator/signature/test_collect_on.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, "#collect_on" do
+
+      subject{ op.class.signature.collect_on(op) }
+      let(:operands){  subject.first }
+      let(:arguments){ subject[1]    }
+      let(:options){   subject[2]    }
+      
+      describe "on a nullary op" do
+        let(:op){ Alf.lispy.run %w{generator -- 10 -- id} } 
+        it { should eq([[], [10, :id], {}]) }
+      end
+
+      describe "on a monadic op, with one arg" do
+        let(:op){ Alf.lispy.run %w{autonum suppliers -- id} } 
+        specify{
+          operands.collect{|o| o.class}.should eq([Iterator::Proxy])
+          arguments.should eq([:id])
+          options.should eq({})
+        }
+      end
+
+      describe "on a monadic op, with one arg and an option" do
+        let(:op){ Alf.lispy.run %w{project --allbut suppliers -- name city} } 
+        specify{
+          operands.collect{|o| o.class}.should eq([Iterator::Proxy])
+          arguments.should eq([AttrList.new([:name, :city])])
+          options.should eq({:allbut => true})
+        }
+      end
+
+      describe "on a dyadic op" do
+        let(:op){ Alf.lispy.run %w{join suppliers cities} } 
+        specify{
+          operands.collect{|o| o.class}.should eq([Iterator::Proxy, Iterator::Proxy])
+          arguments.should eq([])
+          options.should eq({})
+        }
+      end
+
+    end
+  end # module Operator
+end # module Alf

data/spec/unit/operator/signature/test_initialize.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, '.initialize' do
+
+      it "should yield the signature" do
+        sig = Signature.new(nil){|s|
+          s.argument :name, AttrName, :autonum
+          s.option :allbut, Boolean, true, "Applies an allbut projection?"
+        }
+        sig.arguments.should eql([[:name, AttrName, :autonum, nil]])
+        sig.options.should eql([[:allbut, Boolean, true, "Applies an allbut projection?"]])
+      end
+
+    end
+  end
+end

data/spec/unit/operator/signature/test_install.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, '.install' do
+      
+      let(:clazz){ Class.new(Object) }
+      subject{ signature.install }
+      
+      describe "on an empty signature" do
+        let(:signature){ Signature.new(clazz) }
+        it{ should eq({}) }
+        specify{
+          lambda{ subject }.should_not raise_error
+        }
+      end
+      
+      describe "on a non empty signature" do
+
+        let(:signature){ 
+          Signature.new(clazz) do |s|
+            s.argument :attrname, AttrName
+            s.argument :ordering, Ordering
+            s.option   :allbut,   Boolean, true
+          end 
+        }
+
+        it{ should eq(:allbut => true) }
+
+        it "should have arguments installed as attr accessors" do
+          subject
+          inst = clazz.new
+          inst.should respond_to(:attrname)
+          inst.send(:"attrname=", :hello)
+          inst.attrname.should eq(:hello)
+        end
+   
+        it "should have options installed as attr accessors" do
+          subject
+          inst = clazz.new
+          inst.should respond_to(:allbut)
+          inst.send(:"allbut=", true)
+          inst.allbut.should be_true
+        end
+
+        it "should apply auto-coercion" do
+          subject
+          inst = clazz.new
+          inst.send(:"allbut=", "true")
+          inst.allbut.should be_true
+        end
+
+      end
+      
+    end
+  end
+end

data/spec/unit/operator/signature/test_option_parser.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, '#option_parser' do
+
+      let(:clazz){ Class.new(Object) }
+      let(:signature){
+        Signature.new(clazz) do |s|
+          s.option :allbut, Boolean,  true
+          s.option :name,   AttrName, :autonum
+        end
+      }
+      let(:receiver){ clazz.new }
+      before{ signature.install }
+      subject{ signature.option_parser(receiver) }
+
+      specify "expected" do
+        opt = OptionParser.new 
+        opt.on("--allbut"){ receiver.send(:allbut=,true) }
+        opt.on("--name=NAME"){|val| receiver.send(:name=,val) }
+        opt.parse!(["--allbut","--name=world"])
+        receiver.allbut.should be_true
+        receiver.name.should eq(:world)
+      end
+
+      it { should be_a(OptionParser) }
+
+      it "should install option values correctly" do
+        subject.parse!(["--allbut","--name=world"])
+        receiver.allbut.should be_true
+        receiver.name.should eq(:world)
+      end
+
+    end
+  end
+end

data/spec/unit/operator/signature/test_parse_args.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, "#parse_args" do
+      
+      let(:clazz){ Class.new(Object) }
+      let(:receiver){ clazz.new }
+      before{ 
+        signature.install
+      }
+      subject{
+        signature.parse_args(args, receiver)
+        receiver
+      }
+        
+      describe "on a singleton signature with a AttrList" do
+        let(:signature){ 
+          Signature.new(clazz) do |s|
+            s.argument :proj, AttrList
+          end
+        }
+        let(:args){ [%w{hello world}] }
+        specify{
+          subject.proj.should eq(AttrList.new([:hello, :world])) 
+        }
+      end
+      
+      describe "on a singleton signature with a default" do
+        let(:signature){ 
+          Signature.new(clazz) do |s|
+            s.argument :attrname, AttrName, :autonum
+          end
+        }
+        let(:args){ [] }
+        specify{
+          subject.attrname.should eq(:autonum) 
+        }
+      end
+      
+      describe "on a signature with options" do
+        let(:signature){
+          Signature.new(clazz) do |s|
+            s.argument :key, AttrList, []
+            s.option   :allbut, Boolean, false
+          end
+        }
+
+        describe "when no option is provided" do
+          let(:args){ [[:hello, :world]] }
+          specify{
+            subject.key.should eql(AttrList.new([:hello, :world]))
+            subject.allbut.should eql(false)
+          }
+        end
+
+      end
+
+    end
+  end
+end