alf 0.9.3 → 0.10.0

data/spec/spec_helper.rb

@@ -4,12 +4,6 @@ require "rspec"
 
 Alf::Lispy.extend(Alf::Lispy)
 
-def rel(*args)
-  Alf::Relation.coerce(args)
-end
-def tuple(h)
-  h
-end
 def _(path, file)
   File.expand_path("../#{path}", file)
 end
@@ -19,4 +13,4 @@ def wlang(str, binding)
 end
 
 require 'shared/an_operator_class'
-require 'shared/a_value'
+require 'shared/a_value'

data/spec/unit/assumptions/test_set.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'set'
+describe Set do
+  
+  specify "empty sets should be equal" do
+    Set.new([]).should eq(Set.new([]))
+    Set.new([]).should eql(Set.new([]))
+  end
+  
+  describe "on DEE-like sets" do
+    let(:dee){ Set.new([{}]) }
+      
+    specify "DEE sets should be equal" do
+      Set.new([{}]).should eq(dee)
+      Set.new([{}]).should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (1)" do
+      arr = [{}]
+      Set.new(arr).should eq(dee)
+      Set.new(arr).should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (2)" do
+      arr = [{}]
+      Set.new(arr.to_a).should eq(dee)
+      Set.new(arr.to_a).should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (3)" do
+      arr = [{}]
+      arr.to_set.should eq(dee)
+      arr.to_set.should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (4)" do
+      arr = [{}]
+      arr.to_set.should eq(dee)
+      arr.to_set.should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (5)" do
+      arr = Object.new.extend(Enumerable)
+      def arr.each
+        yield({})
+      end
+      arr.to_set.should eq(dee)
+      arr.to_set.should eql(dee)
+    end
+    
+    specify "DEE-like sets should be equal (5)" do
+      arr = Object.new.extend(Enumerable)
+      def arr.each
+        tuple = {:sid => "1"} 
+        tuple.delete(:sid)
+        yield(tuple)
+      end
+      arr.to_set.should eq(dee)
+      arr.to_set.should eql(dee)
+    end
+
+  end  
+
+end

data/spec/unit/command/doc_manager/dynamic.md

@@ -0,0 +1 @@
+#(command_name)

data/spec/unit/command/doc_manager/example.md

@@ -0,0 +1 @@
+  !(alf autonum suppliers -- unique_id)

data/spec/unit/command/doc_manager/example_1.txt

@@ -0,0 +1,11 @@
+  $ alf autonum suppliers -- unique_id
+  
+    +------+-------+---------+--------+------------+
+    | :sid | :name | :status | :city  | :unique_id |
+    +------+-------+---------+--------+------------+
+    | S1   | Smith |      20 | London |          0 |
+    | S2   | Jones |      10 | Paris  |          1 |
+    | S3   | Blake |      30 | Paris  |          2 |
+    | S4   | Clark |      20 | London |          3 |
+    | S5   | Adams |      30 | Athens |          4 |
+    +------+-------+---------+--------+------------+

data/spec/unit/command/doc_manager/static.md

@@ -0,0 +1 @@
+Hello

data/spec/unit/command/doc_manager/test_call.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+module Alf
+  module Command
+    describe DocManager, ".call" do
+
+      let(:dm){ @dm ||= DocManager.new }
+      let(:cmd){ Alf::Command::Show }
+      subject{ 
+        dm.call(cmd, opts) 
+      }
+
+      describe "without options" do
+        let(:opts){ {} }
+
+        describe "on a static file" do
+          before{ 
+            def dm.find_file(cmd); 
+              File.expand_path('../static.md', __FILE__)
+            end 
+          }
+          it { should eq("Hello\n") }
+        end
+
+        describe "on a dynamic file" do
+          before{ 
+            def dm.find_file(cmd); 
+              File.expand_path('../dynamic.md', __FILE__)
+            end 
+          }
+          it { should eq("show\n") }
+        end
+
+        unless RUBY_VERSION < "1.9"
+          describe "on an example file" do
+            before{ 
+              def dm.find_file(cmd); 
+                File.expand_path('../example.md', __FILE__)
+              end 
+            }
+            it { should eq(File.read(File.expand_path('../example_1.txt', __FILE__))) }
+          end
+        end
+
+      end
+
+
+    end
+  end
+end

data/spec/unit/csv/input.csv

@@ -0,0 +1,3 @@
+size
+10
+20

data/spec/unit/csv/test_reader.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+module Alf
+  module CSV
+    describe Reader do
+    
+      describe "without options" do
+        let(:input){ 
+          StringIO.new << "size\n10\n20\n"
+        }
+        let(:expected){
+          [{:size => "10"}, {:size => "20"}]
+        }
+        subject{ reader.to_a }
+          
+        describe "when called on a reader directly" do
+          let(:reader){
+            ::Alf::CSV::Reader.new(input)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through registered one" do
+          let(:reader){
+            ::Alf::Reader.reader(_('input.csv', __FILE__))
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through factory method" do
+          let(:reader){
+            ::Alf::Reader.csv(input)
+          }
+          it{ should eq(expected) }
+        end
+      end
+      
+      describe "with options" do
+        let(:input){ 
+          StringIO.new << "size;name\n10;blambeau\n20;mmathieu\n"
+        }
+        let(:options){
+          {:col_sep => ";"}
+        }
+        let(:expected){
+          [{:size => "10", :name => 'blambeau'}, {:size => "20", :name => 'mmathieu'}]
+        }
+        subject{ reader.to_a }
+          
+        describe "when called on a reader directly" do
+          let(:reader){
+            ::Alf::CSV::Reader.new(input, options)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through factory method" do
+          let(:reader){
+            ::Alf::Reader.csv(input, options)
+          }
+          it{ should eq(expected) }
+        end
+      end
+      
+    end
+  end
+end

data/spec/unit/csv/test_renderer.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+module Alf
+  module CSV
+    describe Renderer do
+    
+      describe "without options" do
+        let(:input){ 
+          [{:size => 10}, {:size => 20}]
+        }
+        let(:expected){
+          "size\n10\n20\n"
+        }
+        subject{ renderer.execute(StringIO.new).string }
+          
+        describe "when called on a renderer directly" do
+          let(:renderer){
+            ::Alf::CSV::Renderer.new(input)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through registererd one" do
+          let(:renderer){
+            ::Alf::Renderer.renderer(:csv, input)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through factory method" do
+          let(:renderer){
+            ::Alf::Renderer.csv(input)
+          }
+          it{ should eq(expected) }
+        end
+      end
+      
+      describe "with options" do
+        let(:input){ 
+          [{:size => 10, :name => "blambeau"}, {:size => 20, :name => "mmathieu"}]
+        }
+        let(:expected){
+          "size;name\n10;blambeau\n20;mmathieu\n"
+        }
+        let(:options){
+          {:col_sep => ";"}
+        }
+        subject{ renderer.execute(StringIO.new).string }
+          
+        describe "when called on a renderer directly" do
+          let(:renderer){
+            ::Alf::CSV::Renderer.new(input, options)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through registererd one" do
+          let(:renderer){
+            ::Alf::Renderer.renderer(:csv, input, options)
+          }
+          it{ should eq(expected) }
+        end
+        
+        describe "when called through factory method" do
+          let(:renderer){
+            ::Alf::Renderer.csv(input, options)
+          }
+          it{ should eq(expected) }
+        end
+      end
+      
+    end
+  end
+end

data/spec/unit/lispy/test_relation.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+module Alf
+  describe Lispy, "Relation(...)" do
+    let(:lispy){ Alf.lispy }
+    subject{ lispy.Relation(*args) }
+
+    describe 'on a single tuple' do
+      let(:args){ [{:name => "Alf"}] }
+      it{ should eq(Relation[*args]) }
+    end
+
+    describe 'on two tuples' do
+      let(:args){ [{:name => "Alf"}, {:name => "Lispy"}] }
+      it{ should eq(Relation[*args]) }
+    end
+
+    describe 'on a Symbol' do
+      let(:args){ [:suppliers] }
+      specify{ 
+        subject.should eq(lispy.environment.dataset(:suppliers).to_rel) 
+      }
+    end
+
+    describe "on the documentation example" do
+      specify {
+        lispy.evaluate{
+          Relation(
+            Tuple(:pid => 'P1', :name => 'Nut',   :color => 'red',   :heavy => true ),
+            Tuple(:pid => 'P2', :name => 'Bolt',  :color => 'green', :heavy => false),
+            Tuple(:pid => 'P3', :name => 'Screw', :color => 'blue',  :heavy => false)
+          )      
+        }.should be_a(Relation)
+      }
+    end
+
+  end
+end

data/spec/unit/lispy/test_run.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+module Alf
+  describe Lispy, ".run" do
+
+    let(:cities){Relation[
+      {:city => "London"},
+      {:city => "Paris"},
+      {:city => "Athens"}
+    ]}
+
+    let(:lispy){ Alf.lispy(Environment.examples) }
+    subject{ lispy.run(args).to_rel }
+
+    describe "without any pipe, on a String" do
+      let(:args){ "project suppliers -- city" }
+      it{ should eq(cities) }
+    end
+
+    describe "without any pipe, on an Array" do
+      let(:args){ %w{project suppliers -- city} }
+      it{ should eq(cities) }
+    end
+
+    describe "with alf explicitely" do
+      let(:args){ %w{alf project suppliers -- city} }
+      it{ should eq(cities) }
+    end
+
+    describe "with piped commands" do
+      let(:args){ %w{alf project suppliers -- city | alf extend -- upcased city.upcase} }
+      it{ should eq(cities.extend(:upcased => lambda{ city.upcase })) }
+    end
+
+    describe "with piped commands and a dyadic op" do
+      let(:args){ %w{alf project suppliers -- city | alf matching suppliers} }
+      it{ should eq(cities) }
+    end
+
+  end
+end

data/spec/unit/lispy/test_tuple.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+module Alf
+  describe Lispy, "Tuple(...)" do
+    let(:lispy){ Alf.lispy }
+    subject{ lispy.Tuple(h) }
+
+    describe 'on an empty tuple' do
+      let(:h){ {} }
+      it{ should eq({}) }
+    end
+
+    describe 'on an valid tuple' do
+      let(:h){ {:name => "Alf"} }
+      it{ should eq({:name => "Alf"}) }
+    end
+
+    describe 'on an invalid tuple because of keys' do
+      let(:h){ {12 => "Alf"} }
+      specify{ lambda{subject}.should raise_error(ArgumentError) }
+    end
+
+    describe 'on an invalid tuple because of values' do
+      let(:h){ {:name => nil} }
+      specify{ lambda{subject}.should raise_error(ArgumentError) }
+    end
+
+    describe "on the documentation example" do
+      specify{
+        lispy.evaluate{
+          Tuple(:pid => 'P1', :name => 'Nut', :color => 'red', :heavy => true)
+        }.should eq(:pid => 'P1', :name => 'Nut', :color => 'red', :heavy => true)
+      }
+    end
+
+  end
+end

data/spec/unit/logs/apache_combined.log

@@ -0,0 +1,5 @@
+125.76.230.10 - - [02/Sep/2009:03:33:46 +0200] "GET /cart/install.txt HTTP/1.1" 404 214 "-" "Toata dragostea mea pentru diavola"
+125.76.230.10 - - [02/Sep/2009:03:33:47 +0200] "GET /store/install.txt HTTP/1.1" 404 215 "-" "Toata dragostea mea pentru diavola"
+10.0.1.1 - - [02/Sep/2009:05:08:33 +0200] "GET / HTTP/1.1" 200 30 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/531.9 (KHTML, like Gecko) Version/4.0.3 Safari/531.9"
+10.0.1.1 - - [02/Sep/2009:06:41:51 +0200] "GET / HTTP/1.1" 200 30 "-" "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/531.9 (KHTML, like Gecko) Version/4.0.3 Safari/531.9"
+69.41.0.45 - - [02/Sep/2009:12:02:40 +0200] "GET //phpMyAdmin/ HTTP/1.1" 404 209 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)"

data/spec/unit/logs/postgresql.log

@@ -0,0 +1,29 @@
+2010-10-10 13:50:24 GMT [38626]: [1-1] LOG:  00000: database system was shut down at 2010-10-10 13:49:33 GMT
+2010-10-10 13:50:24 GMT [38626]: [2-1] LOCATION:  StartupXLOG, xlog.c:4816
+2010-10-10 13:50:24 GMT [38624]: [1-1] LOG:  00000: database system is ready to accept connections
+2010-10-10 13:50:24 GMT [38624]: [2-1] LOCATION:  reaper, postmaster.c:2156
+2010-10-10 13:50:24 GMT [38629]: [1-1] LOG:  00000: autovacuum launcher started
+2010-10-10 13:50:24 GMT [38629]: [2-1] LOCATION:  AutoVacLauncherMain, autovacuum.c:520
+2010-10-10 13:52:04 GMT [38747]: [1-1] LOG:  00000: connection received: host=127.0.0.1 port=60020
+2010-10-10 13:52:04 GMT [38747]: [2-1] LOCATION:  BackendInitialize, postmaster.c:3027
+2010-10-10 13:52:04 GMT [38747]: [3-1] LOG:  00000: connection authorized: user=root database=demonstration
+2010-10-10 13:52:04 GMT [38747]: [4-1] LOCATION:  BackendInitialize, postmaster.c:3097
+2010-10-10 13:52:04 GMT [38747]: [5-1] LOG:  00000: duration: 0.329 ms  statement: SHOW clients
+2010-10-10 13:52:05 GMT [38747]: [21-1] LOG:  00000: duration: 0.973 ms  statement:           SELECT tablename
+	            FROM pg_tables
+	           WHERE schemaname IN (E'"$user"',E'public')
+2010-10-10 13:52:07 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs" 
+2010-10-10 13:52:08 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs" 
+2010-10-10 15:00:02 GMT [38747]: [1667-1] LOG:  00000: duration: 0.024 ms  statement: BEGIN
+2010-10-10 15:00:02 GMT [38747]: [1668-1] LOCATION:  exec_simple_query, postgres.c:1081
+2010-10-10 15:00:02 GMT [38747]: [1669-1] LOG:  00000: duration: 0.195 ms  statement: INSERT INTO "delayed_jobs" ("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at", "last_error") VALUES(NULL, NULL, '2010-10-10 15:00:02.159884', E'--- !ruby/object:RuntheChooChootrain {}
+	
+	', '2010-10-10 15:00:02.159884', 0, '2010-10-10 16:00:00.000000', 0, NULL, NULL) RETURNING "id"
+2010-10-10 15:00:02 GMT [38747]: [1670-1] LOCATION:  exec_simple_query, postgres.c:1081
+2010-10-10 15:00:02 GMT [38747]: [1671-1] LOG:  00000: duration: 0.065 ms  statement: COMMIT
+2010-10-10 15:00:02 GMT [38747]: [1672-1] LOCATION:  exec_simple_query, postgres.c:1081
+2010-10-10 15:00:02 GMT [38747]: [1673-1] LOG:  00000: duration: 0.020 ms  statement: BEGIN
+2010-10-10 15:00:02 GMT [38747]: [1674-1] LOCATION:  exec_simple_query, postgres.c:1081
+2010-10-10 15:00:02 GMT [38747]: [1675-1] LOG:  00000: duration: 0.157 ms  statement: DELETE FROM "delayed_jobs" WHERE "id" = 123456
+2010-10-10 15:00:02 GMT [38747]: [1676-1] LOCATION:  exec_simple_query, postgres.c:1081
+2010-10-10 15:00:02 GMT [38747]: [1677-1] LOG:  00000: duration: 0.050 ms  statement: COMMIT

data/spec/unit/logs/test_reader.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+module Alf
+  shared_examples_for "A valid Logs::Reader instance" do
+
+    specify{ reader.should be_a(::Alf::Logs::Reader) }
+    
+    it "should yield a pseudo-relation" do
+      reader.all?{|tuple| tuple.is_a?(Hash)}.should be_true
+    end
+    
+  end
+  describe Logs::Reader do
+    
+    let(:input){ _("apache_combined.log", __FILE__) }
+    
+    describe "when called on a reader directly" do
+      let(:reader){
+        ::Alf::Logs::Reader.new(input)
+      }
+      it_should_behave_like "A valid Logs::Reader instance"
+    end
+    
+    describe "when called through registered one" do
+      let(:reader){
+        ::Alf::Reader.reader(input)
+      }
+      it_should_behave_like "A valid Logs::Reader instance"
+    end
+    
+    describe "when called through factory method" do
+      let(:reader){
+        ::Alf::Reader.logs(input)
+      }
+      it_should_behave_like "A valid Logs::Reader instance"
+    end
+    
+    describe "the auto-detect feature" do
+      let(:reader){ ::Alf::Logs::Reader.new(nil,nil,:file_format => nil) }
+      let(:relation){ reader.to_rel }
+      
+      describe "on postgresql.log" do
+        before{ reader.pipe(_("postgresql.log", __FILE__)) }
+        it_should_behave_like "A valid Logs::Reader instance"
+        specify{ relation.should_not be_empty }
+      end
+      
+      describe "on apache_combined.log" do
+        before{ reader.pipe(_("apache_combined.log", __FILE__)) }
+        it_should_behave_like "A valid Logs::Reader instance"
+        specify{ relation.should_not be_empty }
+      end
+        
+    end
+
+  end
+end

data/spec/unit/operator/non_relational/test_clip.rb

@@ -38,7 +38,7 @@ module Alf
         end
   
         describe "when factored with Lispy" do
-          let(:operator){ Lispy.clip(input, [:a], true) }
+          let(:operator){ Lispy.clip(input, [:a], :allbut => true) }
           it { should == expected } 
         end
   

data/spec/unit/operator/non_relational/test_coerce.rb

@@ -0,0 +1,35 @@
+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
+        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
+          let(:operator){ Lispy.coerce(input, :a => Integer, :b => Float) }
+          it { should == expected } 
+        end
+  
+      end
+  
+    end 
+  end
+end

data/spec/unit/operator/non_relational/test_defaults.rb

@@ -44,12 +44,25 @@ module Alf
         ]}
     
         describe "When factored with Lispy" do 
-          let(:operator){ Lispy.defaults(input, {:a => 1, :b => "b"}, true) }
+          let(:operator){ Lispy.defaults(input, {:a => 1, :b => "b"}, :strict => true) }
           it{ should == expected }
         end
     
       end
+      
+      describe "when used with tuple expressions" do
+        let(:input) {[
+          {:a => nil, :b => "b"},
+        ]}
+        let(:expected) {[
+          {:a => "b", :b => "b"},
+        ]}
+        let(:operator){ 
+          Lispy.defaults(input, {:a => TupleExpression.coerce("b")}) 
+        }
+        it{ should == expected }
+      end
         
     end 
   end
-end
+end

data/spec/unit/operator/non_relational/test_generator.rb

@@ -0,0 +1,78 @@
+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
+        
+        let(:expected){Relation[
+          {:num => 1},
+          {:num => 2},
+          {:num => 3},
+          {:num => 4},
+          {:num => 5},
+          {:num => 6},
+          {:num => 7},
+          {:num => 8},
+          {:num => 9},
+          {:num => 10},
+        ]}
+    
+        describe "When factored 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
+        
+        let(:expected){Relation[
+          {:num => 1},
+          {:num => 2},
+        ]}
+    
+        describe "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
+        
+        let(:expected){Relation[
+          {:id => 1},
+          {:id => 2},
+        ]}
+    
+        describe "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 
+  end
+end