alf 0.9.0

data/spec/operator/relational/join/hash_based_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Join::HashBased do
+        
+      let(:suppliers) {[
+        {:sid => 'S1', :city => 'London'},
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S3', :city => 'Paris'}
+      ]}
+  
+      let(:statuses) {[
+        {:sid => 'S1', :status => 20},
+        {:sid => 'S2', :status => 10},
+        {:sid => 'S3', :status => 30}
+      ]}
+  
+      let(:countries) {[
+        {:city => 'London',    :country => 'England'},
+        {:city => 'Paris',     :country => 'France'},
+        {:city => 'Bruxelles', :country => 'Belgium (until ?)'}
+      ]}
+  
+      let(:operator){ Join::HashBased.new }
+      subject{ operator.to_a }
+  
+      describe "when applied on both candidate keys" do
+        before{ operator.datasets = [suppliers, statuses] }
+        let(:expected){[
+          {:sid => 'S1', :city => 'London', :status => 20},
+          {:sid => 'S2', :city => 'Paris', :status => 10},
+          {:sid => 'S3', :city => 'Paris', :status => 30}
+        ]}
+        it { should == expected }
+      end
+      
+      describe "when applied on a typical foreign key" do
+        let(:expected){[
+          {:sid => 'S1', :city => 'London', :country => 'England'},
+          {:sid => 'S2', :city => 'Paris',  :country => 'France'},
+          {:sid => 'S3', :city => 'Paris',  :country => 'France'}
+        ]}
+        describe "on one way" do
+          before{ operator.datasets = [suppliers, countries] }
+          it { should == expected }
+        end
+        describe "on the other way around" do
+          before{ operator.datasets = [countries, suppliers] }
+          it { should == expected }
+        end
+      end
+      
+      describe "when no attributes are in common" do
+        before{ operator.datasets = [statuses, countries] }
+        let(:expected){
+          statuses.collect{|s| countries.collect{|c| c.merge(s)}}.flatten
+        }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/minus_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Minus do
+        
+      let(:operator_class){ Minus }
+      it_should_behave_like("An operator class")
+        
+      let(:left) {[
+        {:sid => 'S1', :city => 'London'},
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S3', :city => 'Paris'}
+      ]}
+        
+      let(:right) {[
+        {:sid => 'S2', :city => 'Paris'},
+        {:sid => 'S1', :city => 'London'},
+      ]}
+        
+      let(:disjoint) {[
+        {:sid => 'S4', :city => 'Oslo'},
+        {:sid => 'S5', :city => 'Bruxelles'},
+      ]}
+  
+      let(:operator){ Minus.run([]) }
+      subject{ operator.to_a }
+  
+      describe "when applied on the same operand twice" do
+        before{ operator.datasets = [left, left] }
+        it { should be_empty }
+      end
+      
+      describe "when applied on operands sharing tuples" do
+        before{ operator.datasets = [left, right] }
+        let(:expected) {[
+          {:sid => 'S3', :city => 'Paris'}
+        ]}
+        it { should == expected }
+      end
+    
+      describe "when applied on disjoint operands" do
+        before{ operator.datasets = [left, disjoint] }
+        it { should == left }
+      end
+      
+      describe "when factored with Lispy" do
+        let(:operator){ Lispy.minus(left, right) }
+        let(:expected) {[
+          {:sid => 'S3', :city => 'Paris'}
+        ]}
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/nest_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Nest do
+        
+      let(:operator_class){ Nest }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "a", :b => "b", :c => "c"},
+      ]}
+  
+      let(:expected) {[
+        {:nested => {:a => "a", :b => "b"}, :c => "c"}
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "when factored with commandline args" do
+        let(:operator){ Nest.run(["--", "a", "b", "nested"]) }
+        before{ operator.pipe(input) }
+        it { should == expected }
+      end
+  
+      describe "when factored with Lispy" do
+        let(:operator){ Lispy.nest(input, [:a, :b], :nested) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/project_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Project do
+        
+      let(:operator_class){ Project }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "a", :b => "b"},
+        {:a => "a", :b => "b"},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "when used without --allbut" do
+        let(:expected){[{:a => "a"}]}
+  
+        describe "and factored with commandline args" do
+          let(:operator){ Project.run(["--", 'a']) }
+          before{ operator.pipe(input) }
+          it { should == expected } 
+        end
+  
+        describe "and factored with Lispy" do
+          let(:operator){ Lispy.project(input, [:a]) }
+          it { should == expected } 
+        end
+  
+      end # --no-allbut
+  
+      describe "when used with --allbut" do
+        let(:expected){[{:b => "b"}]}
+  
+        describe "and factored with commandline args" do
+          let(:operator){ Project.run(['--allbut', '--', 'a']) }
+          before{ operator.pipe(input) }
+          it { should == expected } 
+        end
+  
+        describe "and factored with Lispy" do
+          let(:operator){ Lispy.allbut(input, [:a]) }
+          it { should == expected } 
+        end
+  
+      end # --allbut
+      
+      describe "when all is projected" do
+        let(:expected){[{}]}
+        
+        describe "when input is not empty" do
+          let(:operator){ Lispy.project(input, []) }
+          it { should == expected } 
+        end
+        
+        describe "when input is empty" do
+          let(:operator){ Lispy.project([], []) }
+          it { should == [] } 
+        end
+        
+      end # all attributes projected
+  
+    end 
+  end
+end

data/spec/operator/relational/quota_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Quota do
+        
+      let(:operator_class){ Quota }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 2},
+        {:a => "via_method", :time => 3},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_reader", :time => 2},
+      ]}
+  
+      let(:expected) {[
+        {:a => "via_method", :time => 1, :time_sum => 1, :time_max => 1},
+        {:a => "via_method", :time => 2, :time_sum => 3, :time_max => 2},
+        {:a => "via_method", :time => 3, :time_sum => 6, :time_max => 3},
+        {:a => "via_reader", :time => 2, :time_sum => 2, :time_max => 2},
+        {:a => "via_reader", :time => 4, :time_sum => 6, :time_max => 4},
+      ]}
+  
+      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) }
+        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(:operator){ Lispy.quota(input, [:a], [:time], aggs) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/rename_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Rename do
+        
+      let(:operator_class){ Rename }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "a", :b => "b"},
+      ]}
+  
+      let(:expected){[
+        {:z => "a", :b => "b"},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "When factored with Lispy" do 
+        let(:operator){ Lispy.rename(input, {:a => :z}) }
+        it{ should == expected }
+      end
+  
+      describe "When factored from commandline args" do
+        let(:operator){ Rename.run(['--', 'a', 'z']) }
+        before{ operator.pipe(input) }
+        it{ should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/restrict_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Restrict do
+        
+      let(:operator_class){ Restrict }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:tested => 1, :other => "b"},
+        {:tested => 30, :other => "a"},
+      ]}
+  
+      let(:expected){[
+        {:tested => 1, :other => "b"}
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "when used with no argument" do
+        let(:operator){ Restrict.run(%w{}) }
+        before{ operator.pipe(input) }
+        it { should == input }
+      end
+  
+      describe "when used with a string" do
+        describe "when factored with commandline args" do
+          let(:operator){ Restrict.run(["--", "tested < 10"]) }
+          before{ operator.pipe(input) }
+          it { should == expected }
+        end
+        describe "when factored with Lispy" do
+          let(:operator){ Lispy.restrict(input, "tested < 10") }
+          it { should == expected }
+        end
+      end
+  
+      describe "when used with arguments" do
+        describe "when factored with commandline args" do
+          let(:operator){ Restrict.run(["--", "tested", "1"]) }
+          before{ operator.pipe(input) }
+          it { should == expected }
+        end
+        describe "when factored with Lispy and Proc" do
+          let(:operator){ Lispy.restrict(input, lambda{ tested < 10 }) }
+          it { should == expected }
+        end
+        describe "when factored with Lispy and array" do
+          let(:operator){ Lispy.restrict(input, [:tested, 1]) }
+          it { should == expected }
+        end
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/summarize/sort_based_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Summarize::SortBased do
+        
+      let(:input) {[
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 2},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_reader", :time => 2},
+      ]}
+  
+      let(:expected) {[
+        {:a => "via_method", :time_sum => 4, :time_max => 2},
+        {: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) }
+  
+      before{ operator.pipe(input) }
+      subject{ operator.to_a }
+  
+      it { should == expected }
+  
+    end 
+  end
+end

data/spec/operator/relational/summarize_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Summarize do
+        
+      let(:operator_class){ Summarize }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "via_reader", :time => 2},
+        {:a => "via_method", :time => 1},
+        {:a => "via_method", :time => 2},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_method", :time => 1},
+      ]}
+  
+      let(:expected) {[
+        {:a => "via_method", :time_sum => 4, :time_max => 2},
+        {:a => "via_reader", :time_sum => 6, :time_max => 4},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "When factored with commandline args" do
+        let(:opts){ ["--by=a"] }
+        let(:aggs){ ["time_sum", "sum(:time)", "time_max", "max(:time)"] }
+        let(:operator){ Summarize.run(opts + ["--"] +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(:operator){ Lispy.summarize(input, [:a], aggs) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/ungroup_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Ungroup do
+        
+      let(:operator_class){ Ungroup }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "via_method", :as => [{:time => 1, :b => "b"}, {:time => 2, :b => "b"}]},
+        {:a => "via_reader", :as => [{:time => 3, :b => "b"}]},
+      ]}
+  
+      let(:expected) {[
+        {:a => "via_method", :time => 1, :b => "b"},
+        {:a => "via_method", :time => 2, :b => "b"},
+        {:a => "via_reader", :time => 3, :b => "b"},
+      ]}
+  
+      subject{ operator.to_a.sort{|k1,k2| k1[:time] <=> k2[:time]} } 
+  
+      describe "when factored with commandline args" do
+        let(:operator) { Ungroup.run(%w{-- as}) } 
+        before{ operator.pipe(input) }
+        it { should == expected }
+      end
+  
+      describe "when factored with Lispy" do
+        let(:operator) { Lispy.ungroup(input, :as) } 
+        it { should == expected }
+      end
+  
+    end 
+  end
+end