alf 0.9.3 → 0.10.0

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, "#parse_argv" do
+      
+      let(:clazz){ Class.new(Object) }
+      let(:receiver){ clazz.new }
+      before{ 
+        signature.install 
+      }
+      subject{
+        signature.parse_argv(argv, receiver)
+      }
+ 
+      describe "on a singleton signature with a AttrList" do
+        let(:signature){ 
+          Signature.new(clazz) do |s|
+            s.argument :proj, AttrList
+          end
+        }
+        let(:argv){ %w{-- hello world} }
+        specify{
+          subject.should eq([])
+          receiver.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(:argv){ %w{} }
+        specify{
+          subject.should eq([])
+          receiver.attrname.should eq(:autonum) 
+        }
+      end
+
+      describe "On quota signature" do
+        let(:signature){
+          Signature.new(clazz) do |s|
+            s.argument :by, AttrList, []
+            s.argument :order, Ordering, []
+            s.argument :summarization, Summarization, {}
+          end
+        }
+        let(:argv){ %w|op1 -- a -- time -- time_sum sum{time} time_max max{time}| }
+        specify{
+          subject.should eq(["op1"])
+          receiver.by.should eq(AttrList.new([:a]))
+          receiver.order.should eq(Ordering.coerce([:time]))
+        }
+      end
+
+      describe "When signature contains options" do
+        let(:signature){
+          Signature.new(clazz) do |s|
+            s.argument :by, AttrList, []
+            s.option :allbut, Boolean, false, "Allbut?"
+          end
+        }
+
+        describe "when options are specified" do
+          let(:argv){ %w{op1 --allbut -- a} }
+          specify{
+            subject.should eq(["op1"])
+            receiver.by.should eq(AttrList.new([:a]))
+            receiver.allbut.should eql(true)
+          }
+        end
+
+        describe "when options are not specified" do
+          let(:argv){ %w{op1 -- a} }
+          specify{
+            subject.should eq(["op1"])
+            receiver.by.should eq(AttrList.new([:a]))
+            receiver.allbut.should eql(false)
+          }
+        end
+
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, '#to_lispy' do
+
+      subject{ signature.to_lispy }
+
+      describe "on a nullary signature" do
+        let(:clazz){ Operator::NonRelational::Generator }
+
+        describe "on an empty signature" do
+          let(:signature){ Signature.new(clazz){|s|} }
+          it{ should eq("(generator)") }
+        end
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("(generator {allbut: Boolean})") }
+        end
+
+      end # nullary signature
+
+      describe "on a monadic operator" do
+        let(:clazz){ Operator::NonRelational::Coerce }
+
+        describe "on an empty signature" do
+          let(:signature){ Signature.new(clazz){|s|} }
+          it{ should eq("(coerce operand)") }
+        end
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("(coerce operand, {allbut: Boolean})") }
+        end
+
+        describe "on an option-only signature with multiple options" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+              s.option :newname, AttrName
+            end
+          }
+          it{ should eq("(coerce operand, {allbut: Boolean, newname: AttrName})") }
+        end
+
+        describe "on a signature with one argument only" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :by, AttrList
+            end
+          }
+          it{ should eq("(coerce operand, by:AttrList)") }
+        end
+
+        describe "on a signature with multiple arguments" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :by, AttrList
+              s.argument :order, Ordering
+            end
+          }
+          it{ should eq("(coerce operand, by:AttrList, order:Ordering)") }
+        end
+
+        describe "on a full signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :by, AttrList
+              s.argument :order, Ordering
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("(coerce operand, by:AttrList, order:Ordering, {allbut: Boolean})") }
+        end
+
+      end
+
+      describe "on a dyadic operator" do
+        let(:clazz){ Operator::Relational::Join }
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("(join left, right, {allbut: Boolean})") }
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+module Alf
+  module Operator
+    describe Signature, '#to_shell' do
+
+      subject{ signature.to_shell }
+
+      describe "on a nullary signature" do
+        let(:clazz){ Operator::NonRelational::Generator }
+
+        describe "on an empty signature" do
+          let(:signature){ Signature.new(clazz){|s|} }
+          it{ should eq("alf generator") }
+        end
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("alf generator [--allbut]") }
+        end
+
+      end # nullary signature
+
+      describe "on a monadic operator" do
+        let(:clazz){ Operator::NonRelational::Coerce }
+
+        describe "on an empty signature" do
+          let(:signature){ Signature.new(clazz){|s|} }
+          it{ should eq("alf coerce [OPERAND]") }
+        end
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("alf coerce [--allbut] [OPERAND]") }
+        end
+
+        describe "on an option-only signature with multiple options" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+              s.option :newname, AttrName
+            end
+          }
+          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND]") }
+        end
+
+        describe "on a signature with one argument only" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :proj, AttrList
+            end
+          }
+          it{ should eq("alf coerce [OPERAND] -- PROJ") }
+        end
+
+        describe "on a signature with multiple arguments" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :proj, AttrList
+              s.argument :ordering, Ordering
+            end
+          }
+          it{ should eq("alf coerce [OPERAND] -- PROJ -- ORDERING") }
+        end
+
+        describe "on a full signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.argument :proj, AttrList
+              s.argument :ordering, Ordering
+              s.option :allbut, Boolean
+              s.option :newname, AttrName
+            end
+          }
+          it{ should eq("alf coerce [--allbut] [--newname=NEWNAME] [OPERAND] -- PROJ -- ORDERING") }
+        end
+
+      end
+
+      describe "on a dyadic operator" do
+        let(:clazz){ Operator::Relational::Join }
+
+        describe "on an option-only signature" do
+          let(:signature){ 
+            Signature.new(clazz) do |s|
+              s.option :allbut, Boolean
+            end
+          }
+          it{ should eq("alf join [--allbut] [LEFT] RIGHT") }
+        end
+
+      end
+
+    end
+  end
+end

data/spec/unit/operator/test_non_relational.rb

@@ -8,11 +8,13 @@ module Alf
       x.sort{|m1,m2| m1.name.to_s <=> m2.name.to_s}.should == [
         Alf::Operator::NonRelational::Autonum,
         Alf::Operator::NonRelational::Clip,
+        Alf::Operator::NonRelational::Coerce,
         Alf::Operator::NonRelational::Compact,
         Alf::Operator::NonRelational::Defaults,
+        Alf::Operator::NonRelational::Generator,
         Alf::Operator::NonRelational::Sort,
       ]
     end
     
   end
-end
+end

data/spec/unit/relation/test_relops.rb

@@ -2,49 +2,54 @@ require 'spec_helper'
 module Alf
   describe Relation do
     
-    let(:rel1){rel(
+    let(:rel1){Alf::Relation[
       {:sid => 'S1'},
       {:sid => 'S2'},
       {:sid => 'S3'}
-    )}
+    ]}
     
-    let(:rel2){rel(
+    let(:rel2){Alf::Relation[
       {:sid => 'S5'},
       {:sid => 'S2'}
-    )}
+    ]}
 
+    specify "project" do
+      rel1.project([]).should eq(Alf::Relation[{}])
+      rel1.project([:sid], :allbut => true).should eq(Alf::Relation[{}])
+    end
+    
     specify "allbut" do
-      rel1.allbut([:sid]).should == rel({})
+      rel1.allbut([:sid]).should eq(Alf::Relation[{}])
     end
     
     specify "extend" do
-      rel1.extend(:x => lambda{ sid.downcase }).should == rel(
+      rel1.extend(:x => lambda{ sid.downcase }).should == Alf::Relation[
         {:sid => 'S1', :x => 's1'},
         {:sid => 'S2', :x => 's2'},
         {:sid => 'S3', :x => 's3'}
-      )
+      ]
     end
       
     specify "union" do
       (rel1 + rel1).should == rel1
-      (rel1 + rel2).should == rel(
+      (rel1 + rel2).should == Alf::Relation[
         {:sid => 'S1'},
         {:sid => 'S3'},
         {:sid => 'S2'},
         {:sid => 'S5'}
-      )
+      ]
     end # coerce
       
     specify "difference" do
-      (rel1 - rel1).should == rel()
-      (rel1 - rel2).should == rel(
+      (rel1 - rel1).should == Alf::Relation[]
+      (rel1 - rel2).should == Alf::Relation[
         {:sid => 'S1'},
         {:sid => 'S3'}
-      )
-      (rel2 - rel1).should == rel(
+      ]
+      (rel2 - rel1).should == Alf::Relation[
         {:sid => 'S5'}
-      )
+      ]
     end # coerce
     
   end
-end
+end

data/spec/unit/sequel/test_environment.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'fileutils'
+require "sequel"
+module Alf
+  describe Sequel::Environment do
+    
+    let(:rel) {Alf::Relation[
+      {: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'}
+    ]}
+
+    let(:file){ _("alf.db", __FILE__) }
+    let(:uri) { "sqlite://#{file}"    }
+    let(:env) { Sequel::Environment.new(uri) }
+    
+    before(:all){
+      unless File.exists?(file) 
+        FileUtils.rm_rf file
+        db = ::Sequel.connect(uri)
+        db.create_table(:suppliers){
+          primary_key :sid
+          String  :sid
+          String  :name
+          Integer :status
+          String  :city
+        }
+        rel.each{|tuple| db[:suppliers].insert(tuple)}
+      end
+    }
+    
+    specify{
+      env.should be_a(Alf::Environment)
+    }
+    
+    it "should serve iterators" do
+      env.dataset(:suppliers).should be_a(Alf::Iterator)
+    end
+    
+    it "should be the correct relation" do
+      env.dataset(:suppliers).to_rel.should eq(rel)
+    end
+    
+    specify ".recognizes?" do
+      Sequel::Environment.recognizes?([_("alf.db", __FILE__)]).should be_true
+      Sequel::Environment.recognizes?(["postgres://localhost/database"]).should be_true
+      Sequel::Environment.recognizes?(["nosuchone.db"]).should be_false
+      Sequel::Environment.recognizes?([nil]).should be_false
+    end
+      
+  end
+end

data/spec/unit/test_aggregator.rb

@@ -9,54 +9,64 @@ module Alf
       {:a => 1, :sign => -1},
     ]}
 
+    it "should keep track of registered aggregators" do
+      Aggregator.aggregators.should_not be_empty
+      Aggregator.each do |agg|
+        agg.should be_a(Class)
+      end
+    end
+
     it "should behave correctly on count" do
-      Aggregator.count(:a).aggregate(input).should == 4
+      Aggregator.count{a}.aggregate(input).should == 4
     end
 
     it "should behave correctly on sum" do
-      Aggregator.sum(:a).aggregate(input).should == 7
+      Aggregator.sum{a}.aggregate(input).should == 7
     end
 
     it "should behave correctly on avg" do
-      Aggregator.avg(:a).aggregate(input).should == 7.0 / 4.0
+      Aggregator.avg{a}.aggregate(input).should == 7.0 / 4.0
     end
 
     it "should behave correctly on min" do
-      Aggregator.min(:a).aggregate(input).should == 1
+      Aggregator.min{a}.aggregate(input).should == 1
     end
 
     it "should behave correctly on max" do
-      Aggregator.max(:a).aggregate(input).should == 3
+      Aggregator.max{a}.aggregate(input).should == 3
     end
 
     it "should behave correctly on concat" do
-      Aggregator.concat(:a).aggregate(input).should == "1231"
-      Aggregator.concat(:a, :between => " ").aggregate(input).should == "1 2 3 1"
-      Aggregator.concat(:a, :before => "[", :after => "]").aggregate(input).should == "[1231]"
+      Aggregator.concat{a}.aggregate(input).should == "1231"
+      Aggregator.concat(:between => " "){ a }.aggregate(input).should == "1 2 3 1"
       Aggregator.concat(:before => "[", :after => "]"){ a }.aggregate(input).should == "[1231]"
     end
 
     it "should behave correctly on collect" do
-      Aggregator.collect(:a).aggregate(input).should == [1, 2, 3, 1]
+      Aggregator.collect{a}.aggregate(input).should == [1, 2, 3, 1]
       Aggregator.collect{ {:a => a, :sign => sign} }.aggregate(input).should == input
     end
 
-    it "should behave correctly on group" do
-      Aggregator.group(:a).aggregate(input).should == rel(
-        {:a => 1},
-        {:a => 2},
-        {:a => 3}
-      )
-      Aggregator.group(:a, :sign).aggregate(input).should == rel(
-        {:a => 1, :sign => -1},
-        {:a => 2, :sign => 1 },
-        {:a => 3, :sign => -1}
-      )
-    end
-
     it "should allow specific tuple computations" do
       Aggregator.sum{ 1.0 * a * sign }.aggregate(input).should == -3.0
     end
+    
+    describe "coerce" do
+     
+      subject{ Aggregator.coerce(arg) }
+      
+      describe "from an Aggregator" do
+        let(:arg){ Aggregator.sum{a} }
+        it{ should eq(arg) }
+      end
+      
+      describe "from a String" do
+        let(:arg){ "sum{a}" }
+        it{ should be_a(Aggregator::Sum) }
+        specify{ subject.aggregate(input).should eql(7) }
+      end
+      
+    end
 
   end
 end

data/spec/unit/test_environment.rb

@@ -22,6 +22,11 @@ module Alf
         env.should be_a(Environment::Folder)
       end
       
+      it "should recognize a sqlite file" do
+        env = Environment.autodetect(_("sequel/alf.db", __FILE__))
+        env.should be_a(Sequel::Environment)
+      end
+      
       it "should raise an Argument when no match" do
         lambda{ Environment.autodetect(12) }.should raise_error(ArgumentError)
       end

data/spec/unit/test_lispy.rb

@@ -19,5 +19,9 @@ module Alf
       operator.to_a.should == expected
     end
 
+    it "should allow building aggregators" do
+      sum{ qty }.should be_a(Aggregator::Sum)
+    end
+
   end
 end

data/spec/unit/test_relation.rb

@@ -46,6 +46,11 @@ module Alf
       it_should_behave_like "A value"  
     end
     
+    specify "different empty relations instances should be equal" do
+      Relation.new(Set.new).should eq(Relation.new(Set.new))
+      Relation[{}].should eq(Relation[{}])
+    end
+    
     describe "DUM" do
       subject{ Relation::DUM }
       it_should_behave_like "A value"

data/spec/unit/text/test_cell.rb

@@ -9,22 +9,22 @@ module Alf
         Cell.new(100).text_rendering.should == "100"
         Cell.new(:hello).text_rendering.should == ":hello"
         Cell.new("hello").text_rendering.should == "hello"
-        Cell.new(10.0).text_rendering.should == "10.0000000"
-        Cell.new(10/3.0).text_rendering.should == "3.3333333"
+        Cell.new(10.0).text_rendering.should == "10.000"
+        Cell.new(10/3.0).text_rendering.should == "3.333"
         Cell.new([]).text_rendering.should == "[]"
-        Cell.new([10/3.0, true]).text_rendering.should == "[3.3333333, true]"
+        Cell.new([10/3.0, true]).text_rendering.should == "[3.333, true]"
       end
 
       specify "min_width" do
         Cell.new("").min_width.should == 0
-        Cell.new(10/3.0).min_width.should == 9
+        Cell.new(10/3.0).min_width.should == 5
         Cell.new("12\n5345").min_width.should == 4
       end
 
       specify "rendering_lines" do
         Cell.new("").rendering_lines.should == []
-        Cell.new(10/3.0).rendering_lines.should == ["3.3333333"]
-        Cell.new([10/3.0,true]).rendering_lines.should == ["[3.3333333, true]"]
+        Cell.new(10/3.0).rendering_lines.should == ["3.333"]
+        Cell.new([10/3.0,true]).rendering_lines.should == ["[3.333, true]"]
         Cell.new("abc").rendering_lines(5).should == ["abc  "]
         Cell.new(12).rendering_lines(5).should == ["   12"]
       end

data/spec/unit/text/test_row.rb

@@ -9,8 +9,8 @@ module Alf
 
         let(:values){ [ 10/3.0, true ] }
         specify "rendering_lines" do
-          row.rendering_lines.should == ["| 3.3333333 | true |"]
-          row.rendering_lines([10,5]).should == ["|  3.3333333 | true  |"]
+          row.rendering_lines.should == ["| 3.333 | true |"]
+          row.rendering_lines([10,5]).should == ["|      3.333 | true  |"]
         end
 
       end
@@ -20,7 +20,7 @@ module Alf
         let(:values){ [ 10/3.0, [1, 2, 3] ] }
 
         specify "rendering_lines" do
-          row.rendering_lines.should == ["| 3.3333333 | [1, 2, 3] |"]
+          row.rendering_lines.should == ["| 3.333 | [1, 2, 3] |"]
         end
 
       end

data/spec/unit/text/test_table.rb

@@ -24,12 +24,12 @@ module Alf
         let(:records){ [ [:by_x, 10.0], [:by_y, 2.0] ] }
 
         specify "render" do
-          table.render.should == "+---------+------------+\n" +
-                                 "| :method | :total     |\n" +
-                                 "+---------+------------+\n" +
-                                 "| :by_x   | 10.0000000 |\n" +
-                                 "| :by_y   |  2.0000000 |\n" +
-                                 "+---------+------------+\n"
+          table.render.should == "+---------+--------+\n" +
+                                 "| :method | :total |\n" +
+                                 "+---------+--------+\n" +
+                                 "| :by_x   | 10.000 |\n" +
+                                 "| :by_y   |  2.000 |\n" +
+                                 "+---------+--------+\n"
         end
 
       end

data/spec/unit/tools/test_coalesce.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+module Alf
+  describe "Tools#coalesce" do
+    
+    it "should support a varargs variant" do
+      Tools.coalesce(:a, nil, :b, :c).should eql(:a)
+      Tools.coalesce(nil, :a, nil, :b, :c).should eql(:a)
+    end
+    
+    it "should support a block for costly computations" do
+      Tools.coalesce(nil){ :hello }.should eql(:hello)
+    end
+    
+  end
+end

data/spec/unit/tools/test_coerce.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+module Alf
+  describe "Tools#coerce" do
+    
+    specify {
+      Tools.coerce("12", Integer).should eql(12)
+    }
+    
+  end
+end