alf 0.9.0 → 0.9.1

data/spec/integration/src/test_minus.alf

@@ -0,0 +1,5 @@
+(specify \
+  "(minus (restrict ...) ...) should be equivalent to (restict ..., lambda{ not(...) })",
+  (rel_equal \
+    (minus :suppliers, (restrict :suppliers, lambda{ city == 'Paris' })),
+    (restrict :suppliers, lambda{ city != 'Paris' })))

data/spec/integration/src/test_project.alf

@@ -0,0 +1,9 @@
+cities = relation(
+  {:city => 'London'}, 
+  {:city => 'Paris'}, 
+  {:city => 'Athens'}
+)
+(specify \
+  "(project ..., [...]) should remove duplicates",
+  (rel_equal \
+    (project :suppliers, [:city]), cities))

data/spec/{alf_spec.rb → integration/test_alf.rb}

@@ -18,30 +18,17 @@ describe Alf do
   end
   
   it "should allow compiling lispy expressions" do
-    lispy.compile{
+    lispy.compile {
       (restrict :suppliers, lambda{ city == 'London'})
     }.to_a.should == expected
   end
-
-  it "should allow defining temporary expressions" do
-    lispy.compile{
-      with(:sup => (dataset :suppliers)) do
-        (restrict :sup, lambda{ city == 'London'})
-      end
-    }.to_a.should == expected
-  end
   
-  it "should allow reusing temporary expressions" do
-    op = lispy.compile do
-      (restrict :suppliers, lambda{ status > 20 })
-    end
-    projection = lispy.with(:kept_suppliers => op) do
-      (project :kept_suppliers, [:city])
-    end
-    projection.to_a.should == [
-      {:city => 'Paris'},
-      {:city => 'Athens'}
-    ]
+  it "should allow evaluating lispy expressions" do
+    rel = lispy.evaluate {
+      (restrict :suppliers, lambda{ city == 'London'})
+    }
+    rel.should be_a(Alf::Relation)
+    rel.should eq(Alf::Relation.coerce(expected))
   end
-
+  
 end

data/spec/integration/test_alf_specs.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+describe "Alf's integration tests" do
+  
+  module Helpers
+    
+    def rel_equal(x, y)
+      x.to_rel == y.to_rel
+    end
+    
+    def specify(message, x)
+      raise message unless x
+    end
+    
+  end
+  
+  shared_examples_for "An integration file" do
+    
+    let(:lispy){
+      lispy = Alf.lispy(Alf::Environment.examples)
+      lispy.ruby_extend(Helpers)
+    }
+
+    it "should work when executed with a Alf" do
+      lispy.compile(File.read(subject))
+    end
+    
+  end # An example
+  
+  
+  Dir["#{File.expand_path('../src', __FILE__)}/**/*.alf"].each do |file|
+    describe file do
+      subject{ file }
+      it_should_behave_like "An integration file"
+    end
+  end
+  
+end

data/spec/{examples_spec.rb → integration/test_examples.rb}

@@ -15,7 +15,7 @@ module Alf
     end # An example
     
     
-    Dir["#{File.expand_path('../../examples', __FILE__)}/**/*.alf"].each do |file|
+    Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file|
       describe file do
         subject{ file }
         it_should_behave_like "An example"

data/spec/spec_helper.rb

@@ -1,8 +1,12 @@
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../../lib', __FILE__)
 require 'alf'
 
 Alf::Lispy.extend(Alf::Lispy)
 
+def rel(*args)
+  Alf::Relation.coerce(args)
+end
+
 shared_examples_for "An operator class" do
 
   it "should not have public set_args, _each and _prepare methods" do
@@ -22,5 +26,19 @@ shared_examples_for "An operator class" do
   it "should have a public each method" do
     operator_class.public_method_defined?(:each).should be_true
   end
+  
+  it "should have a unary? class method" do
+    operator_class.should respond_to(:unary?)
+  end
+
+  it "should have a binary? class method" do
+    operator_class.should respond_to(:binary?)
+  end
+  
+  it "should implement unary? and binary? accurately" do
+    operator_class.unary?.should_not eq(operator_class.binary?)
+    operator_class.unary?.should eq(operator_class.ancestors.include?(Alf::Operator::Unary))
+    operator_class.binary?.should eq(operator_class.ancestors.include?(Alf::Operator::Binary))
+  end
 
 end

data/spec/unit/environment/examples/suppliers.rash

@@ -0,0 +1,5 @@
+{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
+{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
+{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
+{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/spec/{environment/folder_spec.rb → unit/environment/test_folder.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 module Alf
   describe Environment::Folder do
     
-    let(:path){ File.expand_path('../../../examples', __FILE__) }
+    let(:path){ File.expand_path('../examples', __FILE__) }
     let(:env){ Environment::Folder.new(path) }
       
     describe "dataset" do

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Operator::Relational
+    describe Summarize::HashBased do
+        
+      let(:input) {[
+        {:a => "via_method", :time => 1},
+        {:a => "via_reader", :time => 4},
+        {:a => "via_method", :time => 2},
+        {:a => "via_reader", :time => 2},
+        {: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},
+      ]}
+  
+      let(:aggs){{:time_sum => Aggregator.sum(:time),
+                  :time_max => Aggregator.max(:time)}} 
+      let(:operator){ Summarize::HashBased.new(by_key, 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) }
+        it { should == expected }
+      end
+  
+      describe "when allbut is set" do
+        let(:by_key){ Tools::ProjectionKey.new([:time], true) }
+        it { should == expected }
+      end
+  
+    end 
+  end
+end

data/spec/{operator/relational/group_spec.rb → unit/operator/relational/test_group.rb}

@@ -13,8 +13,9 @@ module Alf
       ]}
   
       let(:expected) {[
-        {:a => "via_method", :as => [{:time => 1, :b => "b"}, {:time => 2, :b => "b"}]},
-        {:a => "via_reader", :as => [{:time => 3, :b => "b"}]},
+        {:a => "via_method", :as => rel({:time => 1, :b => "b"}, 
+                                        {:time => 2, :b => "b"})},
+        {:a => "via_reader", :as => rel({:time => 3, :b => "b"})},
       ]}
   
       subject{ operator.to_a.sort{|k1,k2| k1[:a] <=> k2[:a]} }

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

@@ -0,0 +1,36 @@
+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
+        let(:suppliers_by_city){Relation.coerce( 
+          Lispy.group(suppliers, [:sid], :suppliers)
+        )}
+        let(:s2_s3){Relation.coerce([
+          {:sid => 'S3'},
+          {:sid => 'S2'}
+        ])} 
+        let(:right){Relation.coerce([
+          {:suppliers => s2_s3, :hello => "world"}
+        ])}
+        let(:expected){Relation.coerce([
+          {:suppliers => s2_s3, :hello => "world", :city => 'Paris'}
+        ])}
+        subject{Relation.coerce(
+          Lispy.join(suppliers_by_city, right)
+        )}
+        it{ should == expected }
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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, :time_avg => 4.0/3},
+        {: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)}} 
+
+      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) }
+          before{ operator.pipe(input) }
+          it { should == expected }
+        end
+    
+        describe "When factored with Lispy" do
+          let(:operator){ Lispy.summarize(input, [:a], aggs) }
+          it { should == expected }
+        end
+
+      end
+  
+      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) }
+          before{ operator.pipe(input) }
+          it { should == expected }
+        end
+    
+        describe "When factored with Lispy" do
+          let(:operator){ Lispy.summarize(input, [:time], aggs, true) }
+          it { should == expected }
+        end
+
+      end
+  
+    end 
+  end
+end

data/spec/{operator/relational/unnest_spec.rb → unit/operator/relational/test_unwrap.rb}

@@ -1,13 +1,13 @@
 require 'spec_helper'
 module Alf
   module Operator::Relational
-    describe Unnest do
+    describe Unwrap do
         
-      let(:operator_class){ Unnest }
+      let(:operator_class){ Unwrap }
       it_should_behave_like("An operator class")
         
       let(:input) {[
-        {:nested => {:a => "a", :b => "b"}, :c => "c"}
+        {:wrapped => {:a => "a", :b => "b"}, :c => "c"}
       ]}
   
       let(:expected) {[
@@ -17,13 +17,13 @@ module Alf
       subject{ operator.to_a }
   
       describe "when factored with commandline args" do
-        let(:operator){ Unnest.run(%w{-- nested}) }
+        let(:operator){ Unwrap.run(%w{-- wrapped}) }
         before{ operator.pipe(input) }
         it { should == expected }
       end
   
       describe "when factored with Lispy" do
-        let(:operator){ Lispy.unnest(input, :nested) }
+        let(:operator){ Lispy.unwrap(input, :wrapped) }
         it { should == expected }
       end
   

data/spec/{operator/relational/nest_spec.rb → unit/operator/relational/test_wrap.rb}

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

data/spec/unit/operator/test_non_relational.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  describe Operator::NonRelational do
+    
+    specify "each" do
+      x = []
+      Operator::NonRelational.each{|m| x << m}
+      x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
+        Alf::Operator::NonRelational::Autonum,
+        Alf::Operator::NonRelational::Clip,
+        Alf::Operator::NonRelational::Compact,
+        Alf::Operator::NonRelational::Defaults,
+        Alf::Operator::NonRelational::Sort,
+      ]
+    end
+    
+  end
+end

data/spec/unit/operator/test_relational.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Alf
+  describe Operator::Relational do
+    
+    specify "each" do
+      x = []
+      Operator::Relational.each{|m| x << m}
+      x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
+        Alf::Operator::Relational::Extend,
+        Alf::Operator::Relational::Group,
+        Alf::Operator::Relational::Intersect,
+        Alf::Operator::Relational::Join,
+        Alf::Operator::Relational::Minus,
+        Alf::Operator::Relational::Project,
+        Alf::Operator::Relational::Quota,
+        Alf::Operator::Relational::Rename,
+        Alf::Operator::Relational::Restrict,
+        Alf::Operator::Relational::Summarize,
+        Alf::Operator::Relational::Ungroup,
+        Alf::Operator::Relational::Union,
+        Alf::Operator::Relational::Unwrap,
+        Alf::Operator::Relational::Wrap,
+      ]
+    end
+    
+  end
+end

data/spec/unit/reader/test_alf_file.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+module Alf
+  describe Reader::AlfFile do
+    
+    let(:io){ StringIO.new(expr) }
+    def dataset(name)
+      [{:status => 10},{:status => 30}]
+    end
+    subject{ Reader::AlfFile.new(io, self).to_a }
+
+    describe "on pure functional expressions" do
+      let(:expr){ "(restrict :suppliers, lambda{status > 20})" }
+      it{ should == [{:status => 30}]}
+    end
+
+    describe "on impure functional expressions" do
+      let(:expr){
+      <<-EOF
+        xxx = (restrict :suppliers, lambda{status > 20})
+        (extend xxx, :rev => lambda{ -status })
+      EOF
+      }
+      it{ should == [{:status => 30, :rev => -30}]}
+    end
+      
+  end
+end

data/spec/unit/relation/test_coerce.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+    
+    let(:tuples_by_sid){[
+      {:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'},
+      {:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'},
+      {:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+    ]}
+    let(:rel){ Relation.new tuples_by_sid.to_set }
+    let(:tuples_by_name){ tuples_by_sid.sort{|t1,t2| t1[:name] <=> t2[:name]} }
+    
+    describe "coerce" do
+      
+      subject{ Relation.coerce(arg) }
+      
+      describe "with a Relation" do
+        let(:arg){ rel }
+        it{ should be_a(Relation) }
+        it{ should == rel } 
+      end
+    
+      describe "with a set of tuples" do
+        let(:arg){ tuples_by_name.to_set }
+        it{ should be_a(Relation) }
+        it{ should == rel }
+      end
+    
+      describe "with an array of tuples" do
+        let(:arg){ tuples_by_name }
+        it{ should be_a(Relation) }
+        it{ should == rel }
+      end
+      
+      describe "with an iterator" do
+        let(:arg){ Lispy.restrict(tuples_by_name, lambda{ true }) }
+        it{ should be_a(Relation) }
+        it{ should == rel }
+      end
+      
+      describe "with unrecognized arg" do
+        let(:arg){ nil }
+        specify{ lambda{ subject }.should raise_error(ArgumentError) } 
+      end
+      
+      it "should be semi-aliased as []" do
+        Alf::Relation[*tuples_by_name].should == rel
+      end
+
+    end # coerce
+      
+  end
+end

data/spec/unit/relation/test_inspect.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+    
+    let(:rel){Relation.coerce([
+      {:sid => 'S1'},
+      {:sid => 'S2'},
+      {:sid => 'S3'}
+    ])}
+    
+    describe "inspect" do
+      
+      it "should allows the litteral round-trip" do
+        Kernel.eval(rel.inspect).should == rel
+      end
+
+    end # coerce
+      
+  end
+end

data/spec/unit/relation/test_relops.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+module Alf
+  describe Relation do
+    
+    let(:rel1){rel(
+      {:sid => 'S1'},
+      {:sid => 'S2'},
+      {:sid => 'S3'}
+    )}
+    
+    let(:rel2){rel(
+      {:sid => 'S5'},
+      {:sid => 'S2'}
+    )}
+    
+    specify "extend" do
+      rel1.extend(:x => lambda{ sid.downcase }).should == rel(
+        {:sid => 'S1', :x => 's1'},
+        {:sid => 'S2', :x => 's2'},
+        {:sid => 'S3', :x => 's3'}
+      )
+    end
+      
+    specify "union" do
+      (rel1 + rel1).should == rel1
+      (rel1 + rel2).should == rel(
+        {:sid => 'S1'},
+        {:sid => 'S3'},
+        {:sid => 'S2'},
+        {:sid => 'S5'}
+      )
+    end # coerce
+      
+    specify "difference" do
+      (rel1 - rel1).should == rel()
+      (rel1 - rel2).should == rel(
+        {:sid => 'S1'},
+        {:sid => 'S3'}
+      )
+      (rel2 - rel1).should == rel(
+        {:sid => 'S5'}
+      )
+    end # coerce
+    
+  end
+end

data/spec/{aggregator_spec.rb → unit/test_aggregator.rb}

@@ -42,16 +42,16 @@ module Alf
     end
 
     it "should behave correctly on group" do
-      Aggregator.group(:a).aggregate(input).should == [
+      Aggregator.group(:a).aggregate(input).should == rel(
         {:a => 1},
         {:a => 2},
-        {:a => 3},
-      ]
-      Aggregator.group(:a, :sign).aggregate(input).should == [
+        {:a => 3}
+      )
+      Aggregator.group(:a, :sign).aggregate(input).should == rel(
         {:a => 1, :sign => -1},
         {:a => 2, :sign => 1 },
-        {:a => 3, :sign => -1},
-      ]
+        {:a => 3, :sign => -1}
+      )
     end
 
     it "should allow specific tuple computations" do