ruport 1.4.0 → 1.6.0

data/test/csv_formatter_test.rb

@@ -3,7 +3,7 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestRenderCSVRow < Test::Unit::TestCase
   def test_render_csv_row
-    actual = Ruport::Renderer::Row.render_csv(:data => [1,2,3])
+    actual = Ruport::Controller::Row.render_csv(:data => [1,2,3])
     assert_equal("1,2,3\n", actual)
   end
 end
@@ -24,12 +24,12 @@ class TestRenderCSVTable < Test::Unit::TestCase
   end
 
   def test_render_csv_table
-    actual = Ruport::Renderer::Table.render_csv do |r| 
+    actual = Ruport::Controller::Table.render_csv do |r| 
       r.data = Table([], :data => [[1,2,3],[4,5,6]])
     end
     assert_equal("1,2,3\n4,5,6\n",actual)
 
-    actual = Ruport::Renderer::Table.render_csv do |r|
+    actual = Ruport::Controller::Table.render_csv do |r|
       r.data = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     end
     assert_equal("a,b,c\n1,2,3\n4,5,6\n",actual)
@@ -42,7 +42,7 @@ class TestRenderCSVTable < Test::Unit::TestCase
   end
 
   def test_table_headers
-    actual = Ruport::Renderer::Table.
+    actual = Ruport::Controller::Table.
              render_csv(:show_table_headers => false, 
                         :data => Table(%w[a b c], :data => [[1,2,3],[4,5,6]]))
     assert_equal("1,2,3\n4,5,6\n",actual)
@@ -50,7 +50,7 @@ class TestRenderCSVTable < Test::Unit::TestCase
      
   def test_render_with_template
     formatter = Ruport::Formatter::CSV.new
-    formatter.options = Ruport::Renderer::Options.new
+    formatter.options = Ruport::Controller::Options.new
     formatter.options.template = :simple
     formatter.apply_template
     
@@ -112,7 +112,7 @@ class TestRenderCSVGroup < Test::Unit::TestCase
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3],[4,5,6]],
                                     :column_names => %w[a b c])
-    actual = Ruport::Renderer::Group.
+    actual = Ruport::Controller::Group.
              render_csv(:data => group, :show_table_headers => false )
     assert_equal("test\n\n1,2,3\n4,5,6\n",actual)
   end 

data/test/grouping_test.rb

@@ -97,9 +97,9 @@ class TestGroupRendering < Test::Unit::TestCase
   def test_as_throws_proper_errors
     assert_nothing_raised { @group.as(:csv) }
     assert_nothing_raised { @group.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) {
+    assert_raises(Ruport::Controller::UnknownFormatError) {
       @group.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) {
+    assert_raises(Ruport::Controller::UnknownFormatError) {
       @group.to_nothing }
   end
 
@@ -379,9 +379,9 @@ class TestGroupingRendering < Test::Unit::TestCase
   def test_as_throws_proper_errors
     assert_nothing_raised { @grouping.as(:csv) }
     assert_nothing_raised { @grouping.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) {
+    assert_raises(Ruport::Controller::UnknownFormatError) {
       @grouping.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) {
+    assert_raises(Ruport::Controller::UnknownFormatError) {
       @grouping.to_nothing }
   end
 end

data/test/helpers.rb

@@ -1,4 +1,5 @@
 require "test/unit"
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
 require "ruport"
 begin; require "rubygems"; rescue LoadError; nil; end
 require "spec-unit"

data/test/html_formatter_test.rb

@@ -24,16 +24,16 @@ class TestRenderHTMLTable < Test::Unit::TestCase
 
   def test_render_html_basic
     
-    actual = Ruport::Renderer::Table.render_html { |r|
+    actual = Ruport::Controller::Table.render_html { |r|
       r.data = Table([], :data => [[1,2,3],[4,5,6]])
     }          
     
     assert_equal("\t<table>\n\t\t<tr>\n\t\t\t<td>1</td>\n\t\t\t<td>2"+
                  "</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>\n\t\t"+
                  "\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
-                 "\t</tr>\n\t</table>",actual)
+                 "\t</tr>\n\t</table>\n",actual)
 
-    actual = Ruport::Renderer::Table.render_html { |r| 
+    actual = Ruport::Controller::Table.render_html { |r| 
       r.data = Table(%w[a b c], :data => [ [1,2,3],[4,5,6]]) 
     }
     
@@ -41,13 +41,13 @@ class TestRenderHTMLTable < Test::Unit::TestCase
       "\n\t\t\t<th>c</th>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>1</td>"+
       "\n\t\t\t<td>2</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>"+
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
-      "\t</tr>\n\t</table>",actual)   
+      "\t</tr>\n\t</table>\n",actual)   
     
   end
   
   def test_render_with_template
     formatter = Ruport::Formatter::HTML.new
-    formatter.options = Ruport::Renderer::Options.new
+    formatter.options = Ruport::Controller::Options.new
     formatter.options.template = :simple
     formatter.apply_template
     
@@ -102,7 +102,7 @@ end
 class TestRenderHTMLRow < Test::Unit::TestCase
   
   def test_render_html_row
-    actual = Ruport::Renderer::Row.render_html { |r| r.data = [1,2,3] }
+    actual = Ruport::Controller::Row.render_html { |r| r.data = [1,2,3] }
     assert_equal("\t\t<tr>\n\t\t\t<td>1</td>\n\t\t\t<td>2"+
                  "</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n",actual)
   end
@@ -115,25 +115,25 @@ class TestRenderHTMLGroup < Test::Unit::TestCase
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3],[4,5,6]],
                                     :column_names => %w[a b c])
-    actual = Ruport::Renderer::Group.render(:html, :data => group)
+    actual = Ruport::Controller::Group.render(:html, :data => group)
     assert_equal "\t<p>test</p>\n"+
       "\t<table>\n\t\t<tr>\n\t\t\t<th>a</th>\n\t\t\t<th>b</th>"+
       "\n\t\t\t<th>c</th>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>1</td>"+
       "\n\t\t\t<td>2</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>"+
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
-      "\t</tr>\n\t</table>", actual
+      "\t</tr>\n\t</table>\n", actual
   end
 
   def test_render_html_group_without_headers
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3],[4,5,6]],
                                     :column_names => %w[a b c])
-    actual = Ruport::Renderer::Group.render(:html, :data => group,
+    actual = Ruport::Controller::Group.render(:html, :data => group,
       :show_table_headers => false)
     assert_equal "\t<p>test</p>\n\t<table>\n\t\t<tr>\n\t\t\t<td>1</td>"+
       "\n\t\t\t<td>2</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>"+
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
-      "\t</tr>\n\t</table>", actual
+      "\t</tr>\n\t</table>\n", actual
   end                                           
 end
 
@@ -143,33 +143,33 @@ class TestRenderHTMLGrouping < Test::Unit::TestCase
   def test_render_html_grouping
     table = Table(%w[a b c]) << [1,2,3] << [1,1,3] << [2,7,9]
     g = Grouping(table,:by => "a")
-    actual = Ruport::Renderer::Grouping.render(:html, :data => g,
+    actual = Ruport::Controller::Grouping.render(:html, :data => g,
                                                :show_table_headers => false)
 
     assert_equal "\t<p>1</p>\n\t<table>\n\t\t<tr>\n\t\t\t<td>2</td>\n"+
     "\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>1</td>\n\t\t\t"+
-    "<td>3</td>\n\t\t</tr>\n\t</table>\n\t<p>2</p>\n\t<table>\n\t\t<tr>"+
-    "\n\t\t\t<td>7</td>\n\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n", actual
+    "<td>3</td>\n\t\t</tr>\n\t</table>\n\n\t<p>2</p>\n\t<table>\n\t\t<tr>"+
+    "\n\t\t\t<td>7</td>\n\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n\n", actual
   end
 
   def test_render_html_grouping_with_table_headers
     table = Table(%w[a b c]) << [1,2,3] << [1,1,3] << [2,7,9]
     g = Grouping(table,:by => "a")
-    actual = Ruport::Renderer::Grouping.render(:html, :data => g)
+    actual = Ruport::Controller::Grouping.render(:html, :data => g)
 
     assert_equal "\t<p>1</p>\n\t<table>\n\t\t<tr>\n\t\t\t<th>b</th>\n"+
                  "\t\t\t<th>c</th>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>"+
                  "2</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t\t<tr>\n\t\t"+
-                 "\t<td>1</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t</table>\n"+
+                 "\t<td>1</td>\n\t\t\t<td>3</td>\n\t\t</tr>\n\t</table>\n\n"+
                  "\t<p>2</p>\n\t<table>\n\t\t<tr>\n\t\t\t<th>b</th>\n\t\t"+
                  "\t<th>c</th>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>7</td>\n"+
-                 "\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n", actual
+                 "\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n\n", actual
   end
 
   def test_render_justified_html_grouping
     table = Table(%w[a b c]) << [1,2,3] << [1,1,3] << [2,7,9]
     g = Grouping(table,:by => "a")
-    actual = Ruport::Renderer::Grouping.render(:html, :data => g,
+    actual = Ruport::Controller::Grouping.render(:html, :data => g,
                                                :style => :justified)
 
     assert_equal "\t<table>\n\t\t<tr>\n\t\t\t<th>a</th>\n\t\t\t<th>b</th>\n"+
@@ -179,7 +179,7 @@ class TestRenderHTMLGrouping < Test::Unit::TestCase
                  "<td>&nbsp;</td>\n\t\t\t<td>1</td>\n\t\t\t<td>3</td>"+
                  "\n\t\t</tr>\n\t\t<tr>\n\t\t\t"+
                  "<td class=\"groupName\">2</td>\n\t\t\t<td>7</td>\n"+
-                 "\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>", actual
+                 "\t\t\t<td>9</td>\n\t\t</tr>\n\t</table>\n", actual
   end
 end  
      

data/test/pdf_formatter_test.rb

@@ -63,7 +63,7 @@ class TestRenderPDFTable < Test::Unit::TestCase
   
   def test_render_with_template
     formatter = Ruport::Formatter::PDF.new
-    formatter.options = Ruport::Renderer::Options.new
+    formatter.options = Ruport::Controller::Options.new
     formatter.options.template = :simple
     formatter.apply_template
     
@@ -193,13 +193,13 @@ class TestRenderPDFTable < Test::Unit::TestCase
   # draw_table has destructive behavior on nested rendering options (#359)
   def test_draw_table_should_not_destroy_nested_rendering_options
      f = Ruport::Formatter::PDF.new   
-     f.options = Ruport::Renderer::Options.new 
+     f.options = Ruport::Controller::Options.new 
      f.options[:table_format] =  
        { :column_options => { :heading => {:justification => :center }}}
      f.draw_table Table(%w[a b c], :data => [[1,2,3],[4,5,6]])  
      assert_equal({ :justification => :center }, 
                   f.options[:table_format][:column_options][:heading])      
-  end
+  end        
     
 end    
 
@@ -326,4 +326,29 @@ class TestPDFFormatterHelpers < Test::Unit::TestCase
     a.draw_text "foo", :left => a.left_boundary + 50, :y => 500
     assert_equal 100, a.cursor
   end
+end  
+  
+class SimpleController < Ruport::Controller
+  stage :foo
+  
+  class PDF < Ruport::Formatter::PDF
+    renders :pdf, :for => SimpleController
+    
+    build :foo do
+      add_text "Blah"
+    end
+  end
+end                                
+
+class TestPDFFinalize < Test::Unit::TestCase
+
+  context "When rendering a PDF" do    
+    def specify_finalize_should_be_called
+      SimpleController.render_pdf do |r|
+        r.formatter.expects(:render_pdf)
+      end 
+    end
+  end
+  
 end
+    

data/test/record_test.rb

@@ -313,11 +313,11 @@ class TestRecord < Test::Unit::TestCase
       end
 
       def specify_as_should_throw_proper_errors
-        assert_raises(Ruport::Renderer::UnknownFormatError) { @a.as(:nothing) } 
+        assert_raises(Ruport::Controller::UnknownFormatError) { @a.as(:nothing) } 
       end 
     
       def specify_to_format_should_throw_proper_errors
-        assert_raises(Ruport::Renderer::UnknownFormatError) { @a.to_nothing }
+        assert_raises(Ruport::Controller::UnknownFormatError) { @a.to_nothing }
       end  
     end   
   

data/test/table_pivot_test.rb

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
+
+class TablePivotSimpleCaseTest < Test::Unit::TestCase
+
+  def setup
+    table = Table('a', 'b', 'c')
+    table << [1,3,6]
+    table << [1,4,7]
+    table << [2,3,8]
+    table << [2,4,9]
+    @pivoted = table.pivot('b', :group_by => 'a', :values => 'c')
+  end
+
+  def test_produces_correct_columns
+    assert_equal(['a', 3, 4], @pivoted.column_names)
+  end
+
+  def test_produces_correct_full_table
+    expected = Table("a",3,4) { |t| t << [1,6,7] << [2,8,9] }
+    assert_equal(expected, @pivoted)
+  end
+
+end
+
+class PivotConvertRowOrderToGroupOrderTest < Test::Unit::TestCase
+
+  def convert(src)
+    Ruport::Data::Table::Pivot.new(
+      nil, nil, nil, nil
+    ).convert_row_order_to_group_order(src)
+  end
+
+  def setup
+    @group = mock('group')
+    @row = mock('row')
+    @group.stubs(:[]).with(0).returns(@row)
+  end
+
+  def test_bare_field_name
+    converted = convert(:field_name)
+    @row.expects(:[]).with(:field_name)
+    converted.call(@group)
+  end
+
+  def test_array_of_field_names
+    converted = convert([:field1, :field2])
+    @row.stubs(:[]).with(:field1).returns('f1val')
+    @row.stubs(:[]).with(:field2).returns('f2val')
+    assert_equal(['f1val', 'f2val'], converted.call(@group))
+  end
+
+  def test_proc_operating_on_row
+    converted = convert(proc {|row| row[:field1] })
+    @row.stubs(:[]).with(:field1).returns('f1val')
+    assert_equal('f1val', converted.call(@group))
+  end
+
+  def test_nil
+    assert_equal(nil, convert(nil))
+  end
+
+end
+
+class PivotPreservesOrdering < Test::Unit::TestCase
+
+  def test_group_column_entries_preserves_order_of_occurrence
+    table = Table('group', 'a', 'b')
+    [
+      [1, 0, 0],
+      [9, 0, 0],
+      [1, 0, 0],
+      [9, 0, 0],
+      [1, 0, 0],
+      [8, 0, 0],
+      [1, 0, 0]
+    ].each {|e| table << e}
+    assert_equal([1,9,8], 
+       Ruport::Data::Table::Pivot.
+       new(table, 'group', 'a', 'b').group_column_entries)
+  end
+
+  def test_resulting_columns_preserve_ordering_of_rows
+    table = Table('group', 'a', 'b', 'c')
+    [
+      [200,   1, 2, 1],
+      [200,   4, 5, 2],
+      [200,   5, 0, 3],
+      [100,   1, 8, 4],
+      [100,   4,11, 5]
+    ].each {|e| table << e}
+    assert_equal(
+      [1,4,5],
+      Ruport::Data::Table::Pivot.new(
+        table, 'group', 'a', 'b', :pivot_order => ['c']
+      ).columns_from_pivot)
+  end
+
+  def test_preserves_ordering
+    table = Table('group', 'a', 'b', 'c')
+    [
+      [200,   1, 2, 3],
+      [200,   4, 5, 6],
+      [100,   1, 8, 9],
+      [100,   4,11,12]
+    ].each {|e| table << e}
+    pivoted = table.pivot('a', :group_by => 'group', :values => 'b')
+    expected = Table("group",1,4) { |t| t << [200,2,5] << [100,8,11] }
+    assert_equal(expected, pivoted)
+  end
+
+  def test_preserves_ordering_on_calculated_column
+    table = Table('group', 'a')
+    [
+      [1, 1], [2, 2], [3, 3]
+    ].each {|e| table << e}
+    table.add_column('pivotme') {|row| 10 - row.group.to_i}
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
+                                     :pivot_order => :name)
+    assert_equal(['group', 7, 8, 9], pivoted.column_names)
+  end
+
+  def test_preserves_ordering_on_calculated_column_with_proc_pivot_order
+    table = Table('group', 'a')
+    [
+      [1, 1], [2, 2], [3, 3]
+    ].each {|e| table << e}
+    table.add_column('pivotme') {|row| 10 - row.group.to_i}
+    pivoted = table.pivot('pivotme', :group_by => 'group', :values => 'a', 
+                                     :pivot_order => proc {|row, pivot| pivot })
+    assert_equal(['group', 7, 8, 9], pivoted.column_names)
+  end
+
+end

data/test/table_test.rb

@@ -438,15 +438,15 @@ class TestTableFormattingHooks < Test::Unit::TestCase
     table = Ruport::Data::Table.new :column_names => %w[a b], 
                                     :data => [[1,2],[3,4],[5,6]]
     assert_equal("a,b\n1,2\n3,4\n5,6\n",table.to_csv)
-    assert_raises(Ruport::Renderer::UnknownFormatError) { table.to_nothing }
+    assert_raises(Ruport::Controller::UnknownFormatError) { table.to_nothing }
   end
 
   def test_as_throws_proper_errors
     a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     assert_nothing_raised { a.as(:csv) }
     assert_nothing_raised { a.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { a.to_nothing }
+    assert_raises(Ruport::Controller::UnknownFormatError) { a.as(:nothing) }
+    assert_raises(Ruport::Controller::UnknownFormatError) { a.to_nothing }
   end
     
 end
@@ -662,6 +662,13 @@ class TestTableColumnOperations < Test::Unit::TestCase
     assert_equal Table(%w[a foo c], :data => [[1,6,6],[4,9,9]]), a
   end 
 
+  def test_ensure_renaming_a_missing_column_fails_silently
+    a = Table(%w[a b c])
+    assert_nothing_raised do
+      a.rename_column("d", "z")
+    end
+  end
+
 end  
 
 class TestTableFromCSV < Test::Unit::TestCase

data/test/text_formatter_test.rb

@@ -79,7 +79,7 @@ class TestRenderTextTable < Test::Unit::TestCase
   
   def test_render_with_template
     formatter = Ruport::Formatter::Text.new
-    formatter.options = Ruport::Renderer::Options.new
+    formatter.options = Ruport::Controller::Options.new
     formatter.options.template = :simple
     formatter.apply_template
     
@@ -165,7 +165,7 @@ end
 class TestRenderTextRow < Test::Unit::TestCase
 
   def test_row_basic
-    actual = Ruport::Renderer::Row.render_text(:data => [1,2,3])
+    actual = Ruport::Controller::Row.render_text(:data => [1,2,3])
     assert_equal("| 1 | 2 | 3 |\n", actual)
   end
 
@@ -180,7 +180,7 @@ class TestRenderTextGroup < Test::Unit::TestCase
                                                %w[interesting red snapper]],
                                     :column_names => %w[i hope so])
 
-    actual = Ruport::Renderer::Group.render_text(:data => group)
+    actual = Ruport::Controller::Group.render_text(:data => group)
     expected = "test:\n\n"+
                "+------------------------------+\n"+
                "|      i      | hope |   so    |\n"+
@@ -197,7 +197,7 @@ class TestRenderTextGroup < Test::Unit::TestCase
                                               %w[interesting red snapper]],
                                    :column_names => %w[i hope so])
    
-    actual = Ruport::Renderer::Group.render(:text, :data => group,
+    actual = Ruport::Controller::Group.render(:text, :data => group,
       :show_table_headers => false )
     expected = "test:\n\n"+
                "+------------------------------+\n"+
@@ -217,7 +217,7 @@ class TestRenderTextGrouping < Test::Unit::TestCase
                                     :column_names => %w[i hope so])
     grouping = Grouping(table, :by => "i")
 
-    actual = Ruport::Renderer::Grouping.render(:text, :data => grouping)
+    actual = Ruport::Controller::Grouping.render(:text, :data => grouping)
     expected = "interesting:\n\n"+
                "+----------------+\n"+
                "| hope |   so    |\n"+
@@ -242,7 +242,7 @@ class TestRenderTextGrouping < Test::Unit::TestCase
                                     :column_names => %w[i hope so])
     grouping = Grouping(table, :by => "i")
 
-    actual = Ruport::Renderer::Grouping.render(:text, :data => grouping,
+    actual = Ruport::Controller::Grouping.render(:text, :data => grouping,
       :show_table_headers => false)
     expected = "interesting:\n\n"+
                "+----------------+\n"+