alf 0.9.0

data/spec/operator/non_relational/autonum_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Autonum do
+        
+      let(:operator_class){ Autonum }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "a"},
+        {:a => "b"},
+        {:a => "a"},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "without providing an attribute name" do
+        
+        let(:expected){[
+          {:a => "a", :autonum => 0},
+          {:a => "b", :autonum => 1},
+          {:a => "a", :autonum => 2},
+        ]}
+    
+        describe "When factored with Lispy" do 
+          let(:operator){ Lispy.autonum(input) }
+          it{ should == expected }
+        end
+    
+        describe "When factored from commandline args" do
+          let(:operator){ Autonum.run([]) }
+          before{ operator.pipe(input) }
+          it{ should == expected }
+        end
+  
+      end
+      
+      describe "when providing an attribute name" do
+        
+        let(:expected){[
+          {:a => "a", :unique => 0},
+          {:a => "b", :unique => 1},
+          {:a => "a", :unique => 2},
+        ]}
+    
+        describe "When factored with Lispy" do 
+          let(:operator){ Lispy.autonum(input, :unique) }
+          it{ should == expected }
+        end
+    
+        describe "When factored from commandline args" do
+          let(:operator){ Autonum.run(["--", "unique"]) }
+          before{ operator.pipe(input) }
+          it{ should == expected }
+        end
+  
+      end
+      
+    end 
+  end
+end

data/spec/operator/non_relational/clip_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Clip do
+  
+      let(:operator_class){ Clip }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:a => "a", :b => "b"},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "When used without --allbut" do
+        let(:expected){[{:a => "a"}]}
+  
+        describe "when factored from commandline" do
+          let(:operator){ Clip.run(%w{-- a}) }
+          before{ operator.pipe(input) }
+          it { should == expected } 
+        end
+  
+        describe "when factored with Lispy" do
+          let(:operator){ Lispy.clip(input, [:a]) }
+          it { should == expected } 
+        end
+  
+      end
+  
+      describe "When used with --allbut" do
+        let(:expected){[{:b => "b"}]}
+  
+        describe "when factored with commandline args" do
+          let(:operator){ Clip.run(%w{--allbut -- a}) }
+          before{ operator.pipe(input) }
+          it { should == expected } 
+        end
+  
+        describe "when factored with Lispy" do
+          let(:operator){ Lispy.clip(input, [:a], true) }
+          it { should == expected } 
+        end
+  
+      end
+  
+    end 
+  end
+end

data/spec/operator/non_relational/compact/buffer_based.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Compact::BufferBased do
+        
+      let(:input) {[
+        {:a => "via_method", :time => 1, :b => "b"},
+        {:a => "via_method", :time => 1, :b => "b"},
+        {:a => "via_method", :time => 2, :b => "b"},
+        {:a => "via_reader", :time => 3, :b => "b"},
+        {:a => "via_reader", :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 }
+  
+      describe "when factored with commandline args" do
+        let(:operator){ Compact::BufferBased.new }
+        before{ operator.pipe(input) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/non_relational/compact/sort_based_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Compact::SortBased do
+        
+      let(:input) {[
+        {:a => "via_method", :time => 1, :b => "b"},
+        {:a => "via_method", :time => 1, :b => "b"},
+        {:a => "via_method", :time => 2, :b => "b"},
+        {:a => "via_reader", :time => 3, :b => "b"},
+        {:a => "via_reader", :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 }
+  
+      describe "when factored with commandline args" do
+        let(:operator){ Compact::SortBased.new }
+        before{ operator.pipe(input) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/non_relational/compact_spec.rb

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

data/spec/operator/non_relational/defaults_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Defaults do
+      
+      let(:operator_class){ Defaults }
+      it_should_behave_like("An operator class")
+        
+      subject{ operator.to_a }
+  
+      describe "when used without --strict" do
+        
+        let(:input) {[
+          {:a => nil, :b => "b"},
+        ]}
+    
+        let(:expected) {[
+          {:a => 1, :b => "b", :c => "blue"},
+        ]}
+    
+        describe "When factored with Lispy" do 
+          let(:operator){ Lispy.defaults(input, :a => 1, :c => "blue") }
+          it{ should == expected }
+        end
+    
+        describe "When factored from commandline args" do
+          let(:operator){ Defaults.run(%w{-- a 1 c 'blue'}) }
+          before{ operator.pipe(input) }
+          it{ should == expected }
+        end
+  
+      end
+        
+      describe "when used with --strict" do
+        
+        let(:input) {[
+          {:a => 3,   :b => "b", :c => "blue"},
+          {:a => nil, :b => "b", :c => "blue"},
+        ]}
+    
+        let(:expected) {[
+          {:a => 3, :b => "b"},
+          {:a => 1, :b => "b"},
+        ]}
+    
+        describe "When factored with Lispy" do 
+          let(:operator){ Lispy.defaults(input, {:a => 1, :b => "b"}, true) }
+          it{ should == expected }
+        end
+    
+      end
+        
+    end 
+  end
+end

data/spec/operator/non_relational/sort_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+module Alf
+  module Operator::NonRelational
+    describe Sort do
+        
+      let(:operator_class){ Sort }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:first => "a", :second => 20,  :third => true},
+        {:first => "b", :second => 10, :third => false},
+        {:first => "a", :second => 1,  :third => true},
+      ]}
+  
+      let(:expected){[
+        {:first => "a", :second => 1,  :third => true},
+        {:first => "a", :second => 20, :third => true},
+        {:first => "b", :second => 10, :third => false},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "When factored with Lispy" do 
+        let(:operator){ Lispy.sort(input, [[:first, :asc], [:second, :asc]]) }
+        it{ should == expected }
+      end
+  
+      describe "When factored from commandline args" do
+        let(:operator){ Sort.run(["--", "first", "asc", "second", "asc"]) }
+        before{ operator.pipe(input) }
+        it{ should == expected }
+      end
+  
+      describe "When used on two args" do 
+        let(:operator){ Lispy.sort(input, [[:second, :asc], [:first, :asc]]) }
+        let(:expected){[
+          {:first => "a", :second => 1,  :third => true},
+          {:first => "b", :second => 10, :third => false},
+          {:first => "a", :second => 20, :third => true},
+        ]}
+        it{ should == expected }
+      end
+  
+      describe "When used on single arg" do 
+        let(:operator){ Lispy.sort(input, [[:second, :asc]]) }
+        let(:expected){[
+          {:first => "a", :second => 1,  :third => true},
+          {:first => "b", :second => 10, :third => false},
+          {:first => "a", :second => 20, :third => true},
+        ]}
+        it{ should == expected }
+      end
+  
+      describe "When used with descending order" do 
+        let(:operator){ Lispy.sort(input, [[:second, :desc]]) }
+        let(:expected){[
+          {:first => "a", :second => 20, :third => true},
+          {:first => "b", :second => 10, :third => false},
+          {:first => "a", :second => 1,  :third => true},
+        ]}
+        it{ should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/extend_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Extend do
+        
+      let(:operator_class){ Extend }
+      it_should_behave_like("An operator class")
+        
+      let(:input) {[
+        {:tested => 1,  :other => "b"},
+        {:tested => 30, :other => "a"},
+      ]}
+  
+      let(:expected){[
+        {:tested => 1,  :other => "b", :big => false},
+        {:tested => 30, :other => "a", :big => true},
+      ]}
+  
+      subject{ operator.to_a }
+  
+      describe "When factored with Lispy" do 
+        let(:operator){ Lispy.extend(input, :big => lambda{ tested > 10 }) }
+        it{ should == expected }
+      end
+  
+      describe "When factored from commandline args" do
+        let(:operator){ Extend.run(%w{-- big} + ["tested > 10"]) }
+        before{ operator.pipe(input) }
+        it{ should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/operator/relational/group_spec.rb

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

data/spec/operator/relational/intersect_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Intersect do
+        
+      let(:operator_class){ Intersect }
+      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){ Intersect.run([]) }
+      subject{ operator.to_a }
+  
+      describe "when applied on the same operand twice" do
+        before{ operator.datasets = [left, left] }
+        it { should == left }
+      end
+      
+      describe "when applied on operands sharing tuples" do
+        before{ operator.datasets = [left, right] }
+        let(:expected) {[
+          {:sid => 'S1', :city => 'London'},
+          {:sid => 'S2', :city => 'Paris'},
+        ]}
+        it { should == expected }
+      end
+    
+      describe "when applied on disjoint operands" do
+        before{ operator.datasets = [left, disjoint] }
+        it { should be_empty }
+      end
+      
+      describe "when factored with Lispy" do
+        let(:operator){ Lispy.intersect(left, right) }
+        let(:expected) {[
+          {:sid => 'S1', :city => 'London'},
+          {:sid => 'S2', :city => 'Paris'},
+        ]}
+        it { should == expected }
+      end
+  
+    end 
+  end
+end