ruport 1.0.2 → 1.2.0

data/test/query_test.rb

@@ -1,4 +1,5 @@
- require "test/helpers"
+#!/usr/bin/env ruby -w 
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
  
  begin
    require 'mocha'
@@ -141,7 +142,7 @@
    end
    
    def test_each_without_block
-     assert_raise (LocalJumpError) { @query[:plain].each }
+     assert_raise(LocalJumpError) { @query[:plain].each }
    end
    
    def test_select_source

data/test/record_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestRecord < Test::Unit::TestCase
 

data/test/renderer_test.rb

@@ -1,4 +1,5 @@
-require 'test/helpers'
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 ###########################################################################
 #
@@ -68,6 +69,15 @@ class TestRenderer < Test::Unit::TestCase
   def test_trivial
     actual = OldSchoolRenderer.render(:text)
     assert_equal "header\nbody\nfooter\n", actual
+  end    
+  
+  context "when using templates" do
+     def specify_apply_template_should_be_called
+       Ruport::Formatter::Template.create(:stub)
+       Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+         r.formatter.expects(:apply_template)
+       end  
+     end
   end
 
   def test_using_io
@@ -79,6 +89,21 @@ class TestRenderer < Test::Unit::TestCase
     assert_equal "", out.read
   end
 
+  def test_using_file
+    begin
+      require "mocha"
+      require "stubba"
+    rescue LoadError
+      $stderr.puts "Warning: Mocha not found -- skipping some Renderer tests"
+    end
+    if Object.const_defined?(:Mocha)
+      f = []
+      File.expects(:open).yields(f)
+      a = OldSchoolRenderer.render(:text, :file => "foo.text")
+      assert_equal "header\nbody\nfooter\n", f[0]
+    end
+  end
+
   def test_formats
     assert_equal( {}, Ruport::Renderer.formats )
     assert_equal( { :text => DummyText },OldSchoolRenderer.formats )
@@ -485,7 +510,7 @@ class TestRendererHooks < Test::Unit::TestCase
       include Ruport::Renderer::Hooks
       renders_as_table
 
-      def renderable_data
+      def renderable_data(format)
         1
       end
     end
@@ -511,7 +536,28 @@ class TestRendererHooks < Test::Unit::TestCase
       assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
     end
 
+    class DummyObject4
+      include Ruport::Renderer::Hooks
+      renders_as_table
+
+      def renderable_data(format)
+        case format
+        when :html
+          1
+        when :csv
+          2
+        end
+      end
+    end
+
+    def specify_should_return_results_of_renderable_data_using_format
+      a = DummyObject4.new
+      rend = mock("renderer")
+      rend.expects(:data=).with(2)
+      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
 
-  end
+  end    
 
 end

data/test/sql_split_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 class TestSqlSplit < Test::Unit::TestCase
 	include Ruport
  	
@@ -10,7 +11,8 @@ class TestSqlSplit < Test::Unit::TestCase
 	end  
 	
 	def test_sql_split_complex
-		sql = File.read 'test/samples/ruport_test.sql'
+		sql = File.read File.join(File.expand_path(File.dirname(__FILE__)),
+		                          *%w[samples ruport_test.sql])
 		split = Query::SqlSplit.new sql
 		assert_equal( 'SELECT * FROM ruport_test', split.last )
 	end

data/test/table_test.rb

@@ -1,4 +1,6 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w 
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
+TEST_SAMPLES = File.join(File.expand_path(File.dirname(__FILE__)), "samples")
 
 class Person < Ruport::Data::Record
   
@@ -35,6 +37,62 @@ class TestTable < Test::Unit::TestCase
     end
   end    
 
+  context "when filtering data" do
+
+    def setup
+      @data = [[1,2,3],[4,5,6],[7,8,9]]
+    end
+
+    def specify_filters_should_discard_unmatched_rows
+      table = Ruport::Data::Table.new(:column_names => %w[a b c],
+                                      :data => [[1,2,3],[4,5,6],[7,8,9]],
+                                      :filters => [ lambda { |r| r.a % 2 == 1 } ] )
+      assert_equal Table(%w[a b c]) << [1,2,3] << [7,8,9], table
+    end     
+    
+    def specify_filters_should_work_on_csvs        
+      only_ids_less_than_3 = lambda { |r| r["id"].to_i < 3 }
+      table = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
+                    :filters => [only_ids_less_than_3])
+      assert_equal ["1","2"], table.map { |r| r["id"] }
+    end
+  end  
+  
+  context "when transforming data" do
+    
+    def setup
+      @data = [[1,2,3],[4,5,6],[7,8,9]] 
+    end
+    
+    def specify_transforms_should_modify_table_data
+     
+     stringify_c = lambda { |r| r.c = r.c.to_s } 
+     add_two_to_all_int_cols = lambda { |r|
+      r.each_with_index do |c,i|
+        if Fixnum === c
+          r[i] += 2
+        end
+      end
+        
+     }                                                           
+     
+     table = Ruport::Data::Table.new(:column_names => %w[a b c],
+                                     :data => @data,
+                                     :transforms => [stringify_c,
+                                                     add_two_to_all_int_cols])
+     assert_equal Table(%w[a b c]) << [3,4,"3"] << [6,7,"6"] << [9,10,"9"],
+                  table
+      
+    end 
+    
+    def specify_transforms_should_work_on_csvs  
+      ids_to_i = lambda { |r| r["id"] = r["id"].to_i }
+      table = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
+                    :filters => [ids_to_i])  
+      assert_equal [1,2,3,4,5], table.map { |r| r["id"] }          
+    end
+  end
+
   def test_to_group
     a =[[1,2,3],[4,5,6]].to_table(%w[a b c]).to_group("Packrats")
     b = Ruport::Data::Group.new( :data => [[1,2,3],[4,5,6]],
@@ -106,8 +164,8 @@ class TestTable < Test::Unit::TestCase
   end
 
   def test_reorder
-    table = Ruport::Data::Table.load("test/samples/data.csv")
-    table.reorder *%w[col1 col3]
+    table = Ruport::Data::Table.load(File.join(TEST_SAMPLES,"data.csv"))
+    table.reorder(*%w[col1 col3])
     assert_equal %w[col1 col3], table.column_names
     rows = [%w[a c], %w[d e]]
     table.each { |r| assert_equal rows.shift, r.to_a
@@ -126,59 +184,93 @@ class TestTable < Test::Unit::TestCase
       assert_equal b.column_names.object_id,
                    r.instance_eval{@attributes}.object_id
     }
-  end
+  end     
   
-  def test_sort_rows_by
-    table = Ruport::Data::Table.new :column_names => %w[a b c]
-    table << [1,2,3] << [6,1,8] << [9,1,4]    
+  context "when sorting rows" do 
     
-    table2 = Ruport::Data::Table.new :column_names => [:a, :b, :c]
-    table2 << [1,2,3] << [6,1,8] << [9,1,4]
-
-    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
-
-    sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
+    def setup
+      @table = Table(%w[a b c]) << [1,2,3] << [6,1,8] << [9,1,4] 
+      @table_with_nils = Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8]
+    end
     
-    sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3] 
+    def specify_should_sort_in_reverse_order_on_descending
+       t = @table.sort_rows_by("a", :order => :descending ) 
+       assert_equal Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], t   
+       
+       t = @table.sort_rows_by("c", :order => :descending ) 
+       assert_equal Table(%w[a b c]) << [6,1,8] << [9,1,4] << [1,2,3], t               
+    end  
     
-    sorted_table_bs = Ruport::Data::Table.new :column_names => [:a, :b, :c]
-    sorted_table_bs << [6,1,8] << [9,1,4] << [1,2,3]
-  
-    assert_equal sorted_table_a,  table.sort_rows_by {|r| r['a']}
-    assert_equal sorted_table_b,  table.sort_rows_by(['b'])
-    assert_equal sorted_table_bc, table.sort_rows_by(['b', 'c'])
-    assert_equal sorted_table_bs, table2.sort_rows_by(:b)
-  end              
-  
-  def test_sort_rows_by!
-    table = Ruport::Data::Table.new :column_names => %w[a b c]
-    table << [1,2,3] << [6,1,8] << [9,1,4]
+    def specify_show_put_rows_with_nil_columns_after_sorted_rows    
+       # should not effect when using columns that are all populated
+       t = @table_with_nils.sort_rows_by("a") 
+       assert_equal Table(%w[a b c]) << [1,nil,3] << [6,1,8] << [9,3,4], t 
+       
+       t = @table_with_nils.sort_rows_by("b")
+       assert_equal Table(%w[a b c]) << [6,1,8] << [9,3,4] << [1,nil,3], t    
+       
+       t = @table_with_nils.sort_rows_by("b", :order => :descending)
+       assert_equal Table(%w[a b c]) << [1,nil,3] << [9,3,4] << [6,1,8], t
+    end
+    
+    def specify_in_place_sort_should_allow_order_by
+       @table.sort_rows_by!("a", :order => :descending )
+       assert_equal Table(%w[a b c]) << [9,1,4] << [6,1,8] << [1,2,3], @table
+    end
+    
+    def specify_sort_rows_by
+      table = Ruport::Data::Table.new :column_names => %w[a b c]
+      table << [1,2,3] << [6,1,8] << [9,1,4]    
+    
+      table2 = Ruport::Data::Table.new :column_names => [:a, :b, :c]
+      table2 << [1,2,3] << [6,1,8] << [9,1,4]
 
-    sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
+      sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
 
-    sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
+      sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
+    
+      sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3] 
     
-    sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
-    sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3]
+      sorted_table_bs = Ruport::Data::Table.new :column_names => [:a, :b, :c]
+      sorted_table_bs << [6,1,8] << [9,1,4] << [1,2,3]
+  
+      assert_equal sorted_table_a,  table.sort_rows_by {|r| r['a']}
+      assert_equal sorted_table_b,  table.sort_rows_by(['b'])
+      assert_equal sorted_table_bc, table.sort_rows_by(['b', 'c'])
+      assert_equal sorted_table_bs, table2.sort_rows_by(:b)
+    end              
+       
+    def specify_sort_rows_by!
+      table = Ruport::Data::Table.new :column_names => %w[a b c]
+      table << [1,2,3] << [6,1,8] << [9,1,4]
+
+      sorted_table_a = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_a << [1,2,3] << [6,1,8] << [9,1,4]
+
+      sorted_table_b = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_b << [6,1,8] << [9,1,4] << [1,2,3]
     
-    table_a = table.dup
-    table_a.sort_rows_by! { |r| r['a'] }       
+      sorted_table_bc = Ruport::Data::Table.new :column_names => %w[a b c]
+      sorted_table_bc << [9,1,4] << [6,1,8] << [1,2,3]
     
-    table_b = table.dup
-    table_b.sort_rows_by!("b")
+      table_a = table.dup
+      table_a.sort_rows_by! { |r| r['a'] }       
     
-    table_bc = table.dup
-    table_bc.sort_rows_by!(['b', 'c'])             
+      table_b = table.dup
+      table_b.sort_rows_by!("b")
+    
+      table_bc = table.dup
+      table_bc.sort_rows_by!(['b', 'c'])             
   
-    assert_equal sorted_table_a,  table_a
-    assert_equal sorted_table_b,  table_b
-    assert_equal sorted_table_bc, table_bc
-  end
+      assert_equal sorted_table_a,  table_a
+      assert_equal sorted_table_b,  table_b
+      assert_equal sorted_table_bc, table_bc
+    end
+    
+  end  
 
   def test_array_hack
     t = [[1,2],[3,4],[5,6]].to_table 
@@ -601,7 +693,7 @@ end
 class TestTableFromCSV < Test::Unit::TestCase
   
   def test_csv_load
-    table = Ruport::Data::Table.load("test/samples/data.csv")
+    table = Ruport::Data::Table.load(File.join(TEST_SAMPLES,"data.csv"))
     assert_equal %w[col1 col2 col3], table.column_names
     rows = [%w[a b c],["d",nil,"e"]]
     table.each { |r| assert_equal rows.shift, r.to_a
@@ -609,14 +701,14 @@ class TestTableFromCSV < Test::Unit::TestCase
     expected = [%w[1 2 3],%w[4 5 6]].to_table(%w[a b c])
     
     # ticket:94
-    table = Ruport::Data::Table.load( "test/samples/data.tsv", 
+    table = Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.tsv"), 
                                       :csv_options => { :col_sep => "\t" } )
     assert_equal expected, table 
 
 
    expected = ['c','e']
    
-   table = Ruport::Data::Table.load( "test/samples/data.csv", :csv_options => 
+   table = Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.csv"), :csv_options => 
     { :headers => true, :header_converters => :symbol } ) do |s,r|
     assert_equal expected.shift, r[:col3]
    end
@@ -626,13 +718,13 @@ class TestTableFromCSV < Test::Unit::TestCase
    
    expected = ['c','e']
    
-   Ruport::Data::Table.load( "test/samples/data.csv", 
+   Ruport::Data::Table.load( File.join(TEST_SAMPLES,"data.csv"), 
                              :records => true ) do |s,r|
       assert_equal expected.shift, r.col3
       assert_kind_of Ruport::Data::Record, r
    end
      
-   table = Ruport::Data::Table.load( "test/samples/data.csv", 
+   table = Ruport::Data::Table.load( File.join(TEST_SAMPLES, "data.csv"), 
                                      :has_names => false )
    assert_equal([],table.column_names)
    assert_equal([%w[col1 col2 col3],%w[a b c],["d",nil,"e"]].to_table, table)
@@ -683,8 +775,8 @@ class TestTableFromCSV < Test::Unit::TestCase
     }
     assert_equal [%w[a b],%w[a b],%w[1 2], %w[1 2],
                   %w[3 4],%w[3 4]].to_table, t
-    x = Ruport::Data::Table.load("test/samples/data.csv") { |s,r|
-      assert_kind_of Ruport::Data::Table, s
+    x = Ruport::Data::Table.load(File.join(TEST_SAMPLES,"data.csv")) { |s,r|
+      assert_kind_of Ruport::Data::Feeder, s
       assert_kind_of Array, r
       s << r
       s << r
@@ -693,13 +785,14 @@ class TestTableFromCSV < Test::Unit::TestCase
   end  
   
   def test_ensure_csv_loading_accepts_table_options
-     a = Table("test/samples/addressbook.csv",:record_class => DuckRecord)
+     a = Table(File.join(TEST_SAMPLES,"addressbook.csv"), 
+                 :record_class => DuckRecord)
      a.each { |r| assert_kind_of(DuckRecord,r) }
   end    
   
   def test_ensure_table_from_csv_accepts_record_class_in_block_usage
-    a = Table("test/samples/addressbook.csv",:record_class => DuckRecord,
-                                             :records => true) do |s,r|
+    a = Table(File.join(TEST_SAMPLES,"addressbook.csv"),
+                :record_class => DuckRecord, :records => true) do |s,r|
        assert_kind_of(DuckRecord,r) 
     end
   end
@@ -711,14 +804,15 @@ class TestTableKernelHack < Test::Unit::TestCase
   def test_simple
     assert_equal [].to_table(%w[a b c]), Table(%w[a b c]) 
     assert_equal [].to_table(%w[a b c]), Table("a","b","c")
-    assert_equal Ruport::Data::Table.load("test/samples/addressbook.csv"),
-                 Table("test/samples/addressbook.csv")
     assert_equal Ruport::Data::Table.load(
-                   "test/samples/addressbook.csv", :has_names => false),
-                 Table('test/samples/addressbook.csv', :has_names => false) 
+                 File.join(TEST_SAMPLES,"addressbook.csv")),
+                 Table(File.join(TEST_SAMPLES,"addressbook.csv"))
+    assert_equal Ruport::Data::Table.load(
+                   File.join(TEST_SAMPLES,"addressbook.csv"), :has_names => false),
+                 Table(File.join(TEST_SAMPLES,"addressbook.csv"), :has_names => false) 
     Table("a","b","c") do |t|
       t << [1,2,3]
-      assert_equal([[1,2,3]].to_table(%w[a b c]), t)
+      assert_equal([[1,2,3]].to_table(%w[a b c]), t.data)
     end
 
     assert_equal Table("a"), Table(%w[a])
@@ -727,16 +821,16 @@ class TestTableKernelHack < Test::Unit::TestCase
 
   def test_iterators
 
-    Table("test/samples/addressbook.csv") do |s,r|
+    Table(File.join(TEST_SAMPLES,"addressbook.csv")) do |s,r|
       assert_kind_of(Array,r)
-      assert_kind_of(Ruport::Data::Table,s)
+      assert_kind_of(Ruport::Data::Feeder,s)
     end
 
     n = 0
 
     Table(:string => "a,b,c\n1,2,3\n4,5,6\n") do |s,r|
       assert_kind_of(Array,r)
-      assert_kind_of(Ruport::Data::Table,s)
+      assert_kind_of(Ruport::Data::Feeder,s)
       n += 1
     end
 
@@ -745,8 +839,8 @@ class TestTableKernelHack < Test::Unit::TestCase
   end
   
   def test_with_file_arg
-    assert_equal Table("test/samples/addressbook.csv"),
-                 Table(:file => "test/samples/addressbook.csv")
+    assert_equal Table(File.join(TEST_SAMPLES,"addressbook.csv")),
+                 Table(:file => File.join(TEST_SAMPLES,"addressbook.csv"))
   end
    
   def test_with_string_arg