alf 0.10.1 → 0.11.0

data/spec/unit/alf-core/operator/non_relational/test_clip.rb

@@ -0,0 +1,35 @@
+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 }
+
+      context "--no-allbut" do
+        let(:expected){[{:a => "a"}]}
+
+        context "with Lispy" do
+          let(:operator){ Lispy.clip(input, [:a]) }
+          it { should == expected } 
+        end
+      end # --no-allbut
+
+      context "--allbut" do
+        let(:expected){[{:b => "b"}]}
+
+        context "with Lispy" do
+          let(:operator){ Lispy.clip(input, [:a], :allbut => true) }
+          it { should == expected } 
+        end
+      end # --allbut
+  
+    end 
+  end
+end

data/spec/unit/{operator → alf-core/operator}/non_relational/test_coerce.rb

@@ -2,34 +2,28 @@ require 'spec_helper'
 module Alf
   module Operator::NonRelational
     describe Coerce do
-  
+
       let(:operator_class){ Coerce }
       it_should_behave_like("An operator class")
-        
+
       let(:input) {Alf::Relation[
         {:a => "12", :b => "14.0"},
       ]}
-  
+
       subject{ operator.to_rel }
-  
-      describe "When used without --strict" do
+
+      context "--no-strict" do
         let(:expected){Alf::Relation[
           {:a => 12, :b => 14.0}
         ]}
-        
-        describe "when factored from commandline" do
-          let(:operator){ Coerce.run(%w{-- a Integer b Float}) }
-          before{ operator.pipe(input) }
-          it { should == expected } 
-        end
-  
-        describe "when factored with Lispy" do
+
+        context "with Lispy" do
           let(:operator){ Lispy.coerce(input, :a => Integer, :b => Float) }
-          it { should == expected } 
+          it { should == expected }
         end
-  
-      end
-  
+
+      end # --no-strict
+
     end 
   end
 end

data/spec/unit/{operator/non_relational/compact/test_sort_based.rb → alf-core/operator/non_relational/test_compact.rb}

@@ -1,30 +1,32 @@
 require 'spec_helper'
 module Alf
   module Operator::NonRelational
-    describe Compact::SortBased do
-        
+    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_method", :time => 1, :b => "b"},
-        {:a => "via_method", :time => 2, :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_method", :time => 2, :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::SortBased.new }
-        before{ operator.pipe(input) }
+
+      context "with Lispy" do
+        let(:operator){ Lispy.compact(input) }
         it { should == expected }
       end
-  
-    end 
+
+    end
   end
-end
+end

data/spec/unit/{operator → alf-core/operator}/non_relational/test_defaults.rb

@@ -2,55 +2,40 @@ 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
-        
+
+      context "--no-strict" do
         let(:input) {[
           {:a => nil, :b => "b"},
         ]}
-    
         let(:expected) {[
           {:a => 1, :b => "b", :c => "blue"},
         ]}
-    
-        describe "When factored with Lispy" do 
+
+        context "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
-        
+
+      end # --no-strict
+
+      describe "--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"}, :strict => true) }
-          it{ should == expected }
-        end
-    
-      end
-      
-      describe "when used with tuple expressions" do
+
+      end # --strict
+
+      context "with tuple expressions" do
         let(:input) {[
           {:a => nil, :b => "b"},
         ]}
@@ -61,8 +46,8 @@ module Alf
           Lispy.defaults(input, {:a => TupleExpression.coerce("b")}) 
         }
         it{ should == expected }
-      end
-        
-    end 
+      end # tuple expressions
+
+    end
   end
 end

data/spec/unit/{operator → alf-core/operator}/non_relational/test_generator.rb

@@ -2,14 +2,13 @@ require 'spec_helper'
 module Alf
   module Operator::NonRelational
     describe Generator do
-        
+
       let(:operator_class){ Generator }
       it_should_behave_like("An operator class")
-        
+
       subject{ operator.to_rel }
-  
-      describe "without providing anything" do
-        
+
+      context "empty args" do
         let(:expected){Relation[
           {:num => 1},
           {:num => 2},
@@ -22,57 +21,40 @@ module Alf
           {:num => 9},
           {:num => 10},
         ]}
-    
-        describe "When factored with Lispy" do 
+
+        context "with Lispy" do 
           let(:operator){ Lispy.generator() }
           it{ should == expected }
         end
-    
-        describe "When factored from commandline args" do
-          let(:operator){ Generator.run(%w{}) }
-          it{ should == expected }
-        end
-  
-      end
-      
-      describe "when providing an size" do
-        
+
+      end # empty args
+
+      context "with a size" do
         let(:expected){Relation[
           {:num => 1},
           {:num => 2},
         ]}
-    
-        describe "When factored with Lispy" do 
+
+        context "When factored with Lispy" do 
           let(:operator){ Lispy.generator(2) }
           it{ should == expected }
         end
-    
-        describe "When factored from commandline args" do
-          let(:operator){ Generator.run(["--", "2"]) }
-          it{ should == expected }
-        end
-  
-      end
-      
-      describe "when providing a size and a name" do
-        
+
+      end # with a size
+
+      context "when providing a size and a name" do
         let(:expected){Relation[
           {:id => 1},
           {:id => 2},
         ]}
-    
-        describe "When factored with Lispy" do 
+
+        context "When factored with Lispy" do 
           let(:operator){ Lispy.generator(2, :id) }
           it{ should == expected }
         end
-    
-        describe "When factored from commandline args" do
-          let(:operator){ Generator.run(["--", "2", "--", "id"]) }
-          it{ should == expected }
-        end
-  
-      end
-      
+
+      end # size and name
+
     end 
   end
 end

data/spec/unit/{operator → alf-core/operator}/non_relational/test_sort.rb

@@ -2,65 +2,59 @@ 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 
+
+      context "with Lispy" do 
         let(:operator){ Lispy.sort(input, [[:first, :asc], [:second, :asc]]) }
-        it{ should == expected }
+        it{ should eq(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]]) }
+
+      context "with one 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 }
+        it{ should eq(expected) }
       end
-  
-      describe "When used on single arg" do 
-        let(:operator){ Lispy.sort(input, [[:second, :asc]]) }
+
+      context "with 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 }
+        it{ should eq(expected) }
       end
-  
-      describe "When used with descending order" do 
+
+      context "in 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 }
+        it{ should eq(expected) }
       end
-  
+
     end 
   end
-end
+end

data/spec/unit/{operator → alf-core/operator}/relational/test_extend.rb

@@ -2,33 +2,27 @@ 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 
+
+      context "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
+end

data/spec/unit/{operator → alf-core/operator}/relational/test_group.rb

@@ -2,54 +2,38 @@ 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 => 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]} }
-  
-      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
+
+      context "--no-allbut" do
+        context "with Lispy" do
           let(:operator){ Lispy.group(input, [:time, :b], :as) }
           it { should == expected }
         end
-        
-      end
+      end # --no-allbut
   
-      describe "with --allbut" do
-          
-        describe "when factored with commandline args" do
-          let(:operator){ Group.run(["--allbut", "--","a", "--", "as"]) }
-          before{ operator.pipe(input) }
-          it { should == expected }
-        end
-    
-        describe "when factored with Lispy" do
+      context "--allbut" do
+        context "with Lispy" do
           let(:operator){ Lispy.group(input, [:a], :as, :allbut => true) }
           it { should == expected }
         end
-        
-      end
-  
+      end # --allbut
+
     end 
   end
 end

data/spec/unit/alf-core/operator/relational/test_heading.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Heading do
+
+      let(:operator_class){ Heading }
+      it_should_behave_like("An operator class")
+
+      let(:input) {[
+        {:tested => 1,    :other => "b"},
+        {:tested => 10.0, :other => "a"},
+      ]}
+
+      let(:expected){[
+        {:tested => Numeric, :other => String},
+      ]}
+
+      subject{ operator.to_a }
+
+      context "with Lispy" do 
+        let(:operator){ Lispy.heading(input) }
+        it{ should == expected }
+      end
+
+    end 
+  end
+end

data/spec/unit/{operator → alf-core/operator}/relational/test_intersect.rb

@@ -2,49 +2,49 @@ 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([]) }
+
+      let(:operator){ Lispy.intersect(*args) }
       subject{ operator.to_a }
-  
-      describe "when applied on the same operand twice" do
-        before{ operator.pipe [left, left] }
-        it { should == left }
+
+      context "with same operand twice" do
+        let(:args){ [left, left] }
+        it { should eq(left) }
       end
-      
-      describe "when applied on operands sharing tuples" do
-        before{ operator.pipe [left, right] }
+
+      context "on operands sharing tuples" do
+        let(:args){ [left, right] }
         let(:expected) {[
           {:sid => 'S1', :city => 'London'},
           {:sid => 'S2', :city => 'Paris'},
         ]}
-        it { should == expected }
+        it { should eq(expected) }
       end
-    
-      describe "when applied on disjoint operands" do
-        before{ operator.pipe [left, disjoint] }
+
+      context "on disjoint operands" do
+        let(:args){ [left, disjoint] }
         it { should be_empty }
       end
-      
-      describe "when factored with Lispy" do
+
+      context "with Lispy" do
         let(:operator){ Lispy.intersect(left, right) }
         let(:expected) {[
           {:sid => 'S1', :city => 'London'},
@@ -52,7 +52,7 @@ module Alf
         ]}
         it { should == expected }
       end
-  
-    end 
+
+    end
   end
-end
+end

data/spec/unit/{operator → alf-core/operator}/relational/test_join.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 module Alf
   module Operator::Relational
     describe Join do
-        
+
       let(:suppliers){Relation.coerce [
         {:sid => 'S1', :city => 'London'},
         {:sid => 'S2', :city => 'Paris'},
         {:sid => 'S3', :city => 'Paris'},
         {:sid => 'S4', :city => 'London'},
         {:sid => 'S5', :city => 'Athens'},
-      ]} 
-      
-      describe "when applied to sub-relations" do
+      ]}
+
+      context "when applied to sub-relations" do
         let(:suppliers_by_city){Relation.coerce( 
           Lispy.group(suppliers, [:sid], :suppliers)
         )}
@@ -28,9 +28,9 @@ module Alf
         subject{Relation.coerce(
           Lispy.join(suppliers_by_city, right)
         )}
-        it{ should == expected }
+        it{ should eq(expected) }
       end
-      
+
     end
   end
-end
+end