ruport 1.2.3 → 1.4.0

data/test/grouping_test.rb

@@ -20,7 +20,7 @@ class TestGroup < Test::Unit::TestCase
   end
 
   def test_should_copy_group
-    @group.create_subgroups("a")
+    @group.send(:create_subgroups, "a")
     copy = @group.dup
     assert_equal 'test', copy.name
     assert_equal Ruport::Data::Record.new([1,2,3],:attributes => %w[a b c]),
@@ -34,7 +34,7 @@ class TestGroup < Test::Unit::TestCase
   end
 
   def test_eql
-    table = [[1,2,3]].to_table(%w[a b c])
+    table = Table(%w[a b c], :data => [[1,2,3]])
 
     group2 = Ruport::Data::Group.new(:name => 'test',
                                      :data => [[1,2,3]],
@@ -47,7 +47,7 @@ class TestGroup < Test::Unit::TestCase
   
   def test_create_subgroups
     group = @group << [4,5,6]
-    group.create_subgroups("a")
+    group.send(:create_subgroups, "a")
     b = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],
                                         :name => 1 ),
@@ -56,7 +56,7 @@ class TestGroup < Test::Unit::TestCase
                                         :name => 4 ) }
     assert_equal b, group.subgroups
     
-    group.create_subgroups("b")
+    group.send(:create_subgroups, "b")
     c = { 2 => Ruport::Data::Group.new( :data => [[3]],
                                         :column_names => %w[c],
                                         :name => 2 ) }
@@ -114,12 +114,12 @@ end
 class TestGrouping < Test::Unit::TestCase
   
   def setup
-    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     @grouping = Ruport::Data::Grouping.new(table, :by => "a")
   end
   
   def test_grouping_constructor
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     b = Ruport::Data::Grouping.new(a, :by => "a")
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],
@@ -174,7 +174,7 @@ class TestGrouping < Test::Unit::TestCase
   end
 
   def test_append
-   a =[[1,2,3],[4,5,6]].to_table(%w[a b c])
+   a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
    @grouping << a.to_group("red snapper")
    assert_equal @grouping["red snapper"], a.to_group("red snapper")
    
@@ -186,7 +186,7 @@ class TestGrouping < Test::Unit::TestCase
   end
 
   def test_grouping_on_multiple_columns
-    a = [[1,2,3,4],[4,5,6,7]].to_table(%w[a b c d])
+    a = Table(%w[a b c d], :data => [[1,2,3,4],[4,5,6,7]])
     b = Ruport::Data::Grouping.new(a, :by => %w[a b c])
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3,4]],
                                         :column_names => %w[b c d],
@@ -366,7 +366,7 @@ end
 class TestGroupingRendering < Test::Unit::TestCase
 
   def setup
-    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     @grouping = Ruport::Data::Grouping.new(table, :by => "a")
   end
   
@@ -397,7 +397,7 @@ class TestGroupingKernelHacks < Test::Unit::TestCase
   end
 
   def test_grouping_kernel_hack
-    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    table = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     grouping = Ruport::Data::Grouping.new(table, :by => "a")
     a = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],

data/test/helpers.rb

@@ -2,6 +2,8 @@ require "test/unit"
 require "ruport"
 begin; require "rubygems"; rescue LoadError; nil; end
 require "spec-unit"
+require "mocha"
+require "stubba"
 
 class Test::Unit::TestCase
   include SpecUnit

data/test/html_formatter_test.rb

@@ -4,11 +4,11 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 class TestRenderHTMLTable < Test::Unit::TestCase
   
   def setup
-    Ruport::Formatter::Template.create(:simple) do |t|
-      t.table_format = {
+    Ruport::Formatter::Template.create(:simple) do |format|
+      format.table = {
         :show_headings  => false
       }
-      t.grouping_format = {
+      format.grouping = {
         :style          => :justified,
         :show_headings  => false
       }
@@ -25,7 +25,7 @@ class TestRenderHTMLTable < Test::Unit::TestCase
   def test_render_html_basic
     
     actual = Ruport::Renderer::Table.render_html { |r|
-      r.data = [[1,2,3],[4,5,6]].to_table
+      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"+
@@ -34,7 +34,7 @@ class TestRenderHTMLTable < Test::Unit::TestCase
                  "\t</tr>\n\t</table>",actual)
 
     actual = Ruport::Renderer::Table.render_html { |r| 
-      r.data = [ [1,2,3],[4,5,6]].to_table(%w[a b c]) 
+      r.data = Table(%w[a b c], :data => [ [1,2,3],[4,5,6]]) 
     }
     
     assert_equal("\t<table>\n\t\t<tr>\n\t\t\t<th>a</th>\n\t\t\t<th>b</th>"+

data/test/pdf_formatter_test.rb

@@ -4,27 +4,27 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 class TestRenderPDFTable < Test::Unit::TestCase
   
   def setup
-    Ruport::Formatter::Template.create(:simple) do |t|
-      t.page_format = {
+    Ruport::Formatter::Template.create(:simple) do |format|
+      format.page = {
         :size   => "LETTER",
         :layout => :landscape
       }
-      t.text_format = {
+      format.text = {
         :font_size => 16
       }
-      t.table_format = {
+      format.table = {
         :show_headings  => false
       }
-      t.column_format = {
+      format.column = {
         :alignment  => :center,
         :width      => 50
       }
-      t.heading_format = {
+      format.heading = {
         :alignment  => :right,
         :bold       => false,
         :title      => "Test"
       }
-      t.grouping_format = {
+      format.grouping = {
         :style => :separated
       }
     end
@@ -32,7 +32,7 @@ class TestRenderPDFTable < Test::Unit::TestCase
 
   def test_render_pdf_basic  
     # can't render without column names
-    data = [[1,2],[3,4]].to_table
+    data = Table([], :data => [[1,2],[3,4]])
     assert_raise(Ruport::FormatterError) do
       data.to_pdf 
     end      
@@ -54,7 +54,7 @@ class TestRenderPDFTable < Test::Unit::TestCase
   # this is just to make sure that the column_opts code is being called.
   # FIXME: add mocks to be sure
   def test_table_with_options
-    data = [[1,2],[3,4]].to_table(%w[a b])
+    data = Table(%w[a b], :data => [[1,2],[3,4]])
     assert_nothing_raised do
       data.to_pdf(:table_format => { 
             :column_options => { :justification => :center } } ) 
@@ -186,9 +186,9 @@ class TestRenderPDFTable < Test::Unit::TestCase
   # PDF::SimpleTable does not handle symbols as column names
   # Ruport should smartly fix this surprising behaviour (#283) 
   def test_tables_should_render_with_symbol_column_name
-    data = [[1,2,3],[4,5,6]].to_table([:a,:b,:c])
+    data = Table([:a,:b,:c], :data => [[1,2,3],[4,5,6]])
     assert_nothing_raised { data.to_pdf }
-  end
+  end   
   
   # draw_table has destructive behavior on nested rendering options (#359)
   def test_draw_table_should_not_destroy_nested_rendering_options
@@ -196,11 +196,11 @@ class TestRenderPDFTable < Test::Unit::TestCase
      f.options = Ruport::Renderer::Options.new 
      f.options[:table_format] =  
        { :column_options => { :heading => {:justification => :center }}}
-     f.draw_table [[1,2,3],[4,5,6]].to_table(%w[a b c])  
+     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    
 
 class TestRenderPDFGrouping < Test::Unit::TestCase                                  
@@ -210,7 +210,7 @@ class TestRenderPDFGrouping < Test::Unit::TestCase
   # As of Ruport 0.10.0, PDF's justified group output was throwing
   # UnknownFormatError  (#288)
   def test_group_styles_should_not_throw_error
-     table = [[1,2,3],[4,5,6],[1,7,9]].to_table(%w[a b c]) 
+     table = Table(%w[a b c], :data => [[1,2,3],[4,5,6],[1,7,9]]) 
      grouping = Grouping(table,:by => "a")
      assert_nothing_raised { grouping.to_pdf } 
      assert_nothing_raised { grouping.to_pdf(:style => :inline) }
@@ -271,6 +271,15 @@ class TestPDFFormatterHelpers < Test::Unit::TestCase
      a.move_cursor(50)
      assert_equal(525,a.cursor)
   end           
+
+  def test_move_up
+    a = Ruport::Formatter::PDF.new
+    a.move_cursor_to(500)
+    a.move_up(50)
+    assert_equal(550,a.cursor)
+    a.move_down(100)
+    assert_equal(450,a.cursor)
+  end
   
   def test_padding
     a = Ruport::Formatter::PDF.new

data/test/record_test.rb

@@ -86,6 +86,11 @@ class TestRecord < Test::Unit::TestCase
     assert_equal @record.b, @record["b"]
     assert_equal @record.c, @record["c"]
     assert_equal @record.d, @record["d"]
+  end            
+  
+  def test_can_has_id
+     record = Ruport::Data::Record.new(:id => 12345) 
+     assert_equal 12345, record.id
   end
 
   def test_nonexistent_accessor

data/test/renderer_test.rb

@@ -63,27 +63,62 @@ class DummyText < Ruport::Formatter
   end
 end   
 
+class VanillaBinary < Ruport::Formatter
+  renders :bin, :for => VanillaRenderer
+  save_as_binary_file
+end
+
 
 class TestRenderer < Test::Unit::TestCase
 
+  def teardown
+    Ruport::Formatter::Template.instance_variable_set(:@templates, nil)
+  end
+
   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 
-     
-     def specify_undefined_template_should_throw_sensible_error
-        assert_raises(Ruport::Formatter::TemplateNotDefined) do
-          Table(%w[a b c]).to_csv(:template => :sub)
-        end 
-     end
+    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 
+
+    def specify_undefined_template_should_throw_sensible_error
+      assert_raises(Ruport::Formatter::TemplateNotDefined) do
+        Table(%w[a b c]).to_csv(:template => :sub)
+      end 
+    end
+  end
+
+  context "when using default templates" do
+    def specify_default_template_should_be_called
+      Ruport::Formatter::Template.create(:default)
+      Table(%w[a b c]).to_csv do |r| 
+        r.formatter.expects(:apply_template)
+        assert r.formatter.template == Ruport::Formatter::Template[:default]
+      end  
+    end
+
+    def specify_specific_should_override_default
+      Ruport::Formatter::Template.create(:default)
+      Ruport::Formatter::Template.create(:stub)
+      Table(%w[a b c]).to_csv(:template => :stub) do |r| 
+        r.formatter.expects(:apply_template)
+        assert r.formatter.template == Ruport::Formatter::Template[:stub]
+      end  
+    end
+
+    def specify_should_be_able_to_disable_templates
+      Ruport::Formatter::Template.create(:default)
+      Table(%w[a b c]).to_csv(:template => false) do |r| 
+        r.formatter.expects(:apply_template).never
+      end  
+    end
   end
 
   def test_using_io
@@ -96,19 +131,23 @@ class TestRenderer < Test::Unit::TestCase
   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
+    f = []
+    File.expects(:open).yields(f)
+    a = OldSchoolRenderer.render(:text, :file => "foo.text")
+    assert_equal "header\nbody\nfooter\n", f[0]
+    
+    f = []
+    File.expects(:open).with("blah","wb").yields(f)
+    VanillaRenderer.render(:bin, :file => "blah")        
+  end       
+  
+  def test_using_file_via_rendering_tools     
+    f = []
+    File.expects(:open).yields(f)  
+    Table(%w[a b c], :data => [[1,2,3],[4,5,6]]).save_as("foo.csv")      
+    assert_equal "a,b,c\n1,2,3\n4,5,6\n", f[0]  
   end
+    
 
   def test_formats
     assert_equal( {}, Ruport::Renderer.formats )
@@ -160,6 +199,36 @@ class TestRenderer < Test::Unit::TestCase
 end
 
 
+class TestFormatterUsingBuild < Test::Unit::TestCase
+  # This formatter uses the build syntax
+  class UsesBuild < Ruport::Formatter
+     renders :text_using_build, :for => VanillaRenderer 
+     
+     build :header do
+       output << "header\n"
+     end
+
+     build :body do
+       output << "body\n"
+     end
+
+     build :footer do
+       output << "footer\n"
+     end     
+  end
+
+  def test_should_render_using_build_syntax
+    assert_equal "header\nbody\nfooter\n",
+      VanillaRenderer.render_text_using_build
+    VanillaRenderer.render_text_using_build do |rend|
+      assert rend.formatter.respond_to?(:build_header)
+      assert rend.formatter.respond_to?(:build_body)
+      assert rend.formatter.respond_to?(:build_footer)
+    end
+  end
+end
+
+
 class TestFormatterWithLayout < Test::Unit::TestCase
   # This formatter is meant to check out a special case in Ruport's renderer,
   # in which a layout method is called and yielded to when defined
@@ -190,13 +259,10 @@ end
 class TestRendererWithManyHooks < Test::Unit::TestCase
   # This provides a way to check several hooks that Renderer supports
   class RendererWithManyHooks < Ruport::Renderer
-
     add_format DummyText, :text
 
     prepare :document
 
-    option :subtitle, :subsubtitle
-
     stage :header
     stage :body
     stage :footer
@@ -264,13 +330,6 @@ class TestRendererWithManyHooks < Test::Unit::TestCase
    assert_equal "pheader\nbody\nfooter\nf", actual
   end
 
-  def test_option_helper
-   RendererWithManyHooks.render_text do |r|
-     r.subtitle = "Test Report"
-     assert_equal "Test Report", r.options.subtitle
-   end
-  end
-
   def test_required_option_helper
    a = RendererWithManyHooks.dup
    a.required_option :title
@@ -295,9 +354,6 @@ end
 class TestRendererWithRunHook < Test::Unit::TestCase
 
   class RendererWithRunHook < Ruport::Renderer
-    
-    include AutoRunner
-
     add_format DummyText, :text
 
     required_option :foo,:bar
@@ -307,6 +363,7 @@ class TestRendererWithRunHook < Test::Unit::TestCase
 
     def run
       formatter.output << "|"
+      super
     end
 
   end
@@ -428,14 +485,14 @@ end
 class TestOptionReaders < Test::Unit::TestCase
   
   class RendererForCheckingOptionReaders < Ruport::Renderer
-    option :foo  
+    required_option :foo  
   end 
   
   class RendererForCheckingPassivity < Ruport::Renderer
     def foo
       "apples"
     end
-    option :foo    
+    required_option :foo    
   end
 
    def setup 
@@ -463,11 +520,10 @@ end
 class TestSetupOrdering < Test::Unit::TestCase
    
   class RendererWithSetup < Ruport::Renderer
-     option :foo
-     stage :bar
-     def setup
-        foo.capitalize!
-     end        
+    stage :bar
+    def setup
+      options.foo.capitalize!
+    end        
   end           
   
   class BasicFormatter < Ruport::Formatter 
@@ -479,12 +535,12 @@ class TestSetupOrdering < Test::Unit::TestCase
   end
   
   def test_render_hash_options_should_be_called_before_setup
-     assert_equal "Hello", RendererWithSetup.render_text(:foo => "hello")
+    assert_equal "Hello", RendererWithSetup.render_text(:foo => "hello")
   end       
   
   def test_render_block_should_be_called_before_setup
-     assert_equal "Hello", 
-                   RendererWithSetup.render_text { |r| r.foo = "hello" }
+    assert_equal "Hello", 
+      RendererWithSetup.render_text { |r| r.options.foo = "hello" }
   end
   
 end