ruport 1.4.0 → 1.6.0

data/lib/ruport/formatter/html.rb

@@ -12,7 +12,7 @@
 #
 module Ruport
   # This class produces HTML output for Ruport's Row, Table, Group, and
-  # Grouping renderers.  It can be subclassed, as it has some helper methods
+  # Grouping controllers.  It can be subclassed, as it has some helper methods
   # that might be useful for custom output.
   #
   # === Rendering Options
@@ -25,8 +25,8 @@ module Ruport
   #
   class Formatter::HTML < Formatter    
     
-    renders :html, :for => [ Renderer::Row, Renderer::Table,
-                             Renderer::Group, Renderer::Grouping ]
+    renders :html, :for => [ Controller::Row, Controller::Table,
+                             Controller::Group, Controller::Grouping ]
 
     # Hook for setting available options using a template. See the template 
     # documentation for the available options and their format.
@@ -48,22 +48,21 @@ module Ruport
       end
     end
     
-    # Uses the Row renderer to build up the table body.
+    # Uses the Row controller to build up the table body.
     # Replaces nil and empty strings with "&nbsp;" 
     def build_table_body
-      render_data_by_row do |rend|
-        r = rend.data
-        rend.data = r.map { |e| e.to_s.empty? ? "&nbsp;" : e }
+      data.each do |row|
+        build_row(row.map { |e| e.to_s.empty? ? "&nbsp;" : e })
       end
     end
 
     # Simply closes the table tag. 
     def build_table_footer
-      output << "\t</table>"
+      output << "\t</table>\n"
     end
   
     # Renders individual rows for the table.
-    def build_row
+    def build_row(data = self.data)
       output <<
         "\t\t<tr>\n\t\t\t<td>" +
         data.to_a.join("</td>\n\t\t\t<td>") +
@@ -77,14 +76,14 @@ module Ruport
     end
 
     # Creates the group body. Since group data is a table, just uses the
-    # Table renderer.
+    # Table controller.
     #
     def build_group_body
       render_table data, options.to_hash
     end
 
     # Generates the body for a grouping. Iterates through the groups and
-    # renders them using the group renderer.
+    # renders them using the group controller.
     #
     def build_grouping_body
       case options.style
@@ -138,7 +137,7 @@ module Ruport
             "</td>\n\t\t</tr>\n"
         end
       end
-      output << "\t</table>"
+      output << "\t</table>\n"
     end
     
     def grouping_columns

data/lib/ruport/formatter/pdf.rb

@@ -15,7 +15,7 @@
 module Ruport
    
   # This class provides PDF output for Ruport's Table, Group, and Grouping
-  # renderers.  It wraps Austin Ziegler's PDF::Writer to provide a higher
+  # controllers.  It wraps Austin Ziegler's PDF::Writer to provide a higher
   # level interface and provides a number of helpers designed to make
   # generating PDF reports much easier.  You will typically want to build
   # subclasses of this formatter to customize it as needed.
@@ -49,8 +49,8 @@ module Ruport
       end
     end
     
-    renders :pdf, :for => [ Renderer::Row, Renderer::Table,
-                            Renderer::Group, Renderer::Grouping ]
+    renders :pdf, :for => [ Controller::Row, Controller::Table,
+                            Controller::Group, Controller::Grouping ]
     
     attr_writer :pdf_writer
 
@@ -104,18 +104,18 @@ module Ruport
       render_pdf unless options.skip_finalize_table
     end
     
-    # Generates a header with the group name for Renderer::Group.
+    # Generates a header with the group name for Controller::Group.
     def build_group_header
       pad(10) { add_text data.name.to_s, :justification => :center }
     end
     
-    # Renders the group as a table for Renderer::Group.
+    # Renders the group as a table for Controller::Group.
     def build_group_body
       render_table data, options.to_hash.merge(:formatter => pdf_writer)
     end
                      
     # Determines which style to use and renders the main body for
-    # Renderer::Grouping.
+    # Controller::Grouping.
     def build_grouping_body 
       case options.style
       when :inline
@@ -382,6 +382,10 @@ module Ruport
           text_opts[:font_size],
           text_opts[:angle] || 0)
         move_cursor_to(ypos)
+      end   
+      
+      def finalize
+        render_pdf
       end
     end   
 

data/lib/ruport/formatter/template.rb

@@ -142,7 +142,7 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 #                   available to
 #                   FasterCSV.new
 #
-class Ruport::Formatter::Template < Ruport::Renderer::Options
+class Ruport::Formatter::Template < Ruport::Controller::Options
   
   # Returns all existing templates in a hash keyed by the template names.
   def self.templates

data/lib/ruport/formatter/text.rb

@@ -13,7 +13,7 @@
 module Ruport
   
   # This class provides text output for Ruport's Row, Table, Group, and
-  # Grouping renderers
+  # Grouping controllers
   #
   # It handles things like automatically truncating tables that go off the
   # edge of the screen in the console, proper column alignment, and pretty
@@ -45,8 +45,8 @@ module Ruport
   # truncating it.  Useful for file output.
   class Formatter::Text < Formatter
    
-    renders [:txt, :text], :for => [ Renderer::Row, Renderer::Table,
-                                     Renderer::Group, Renderer::Grouping ]
+    renders [:txt, :text], :for => [ Controller::Row, Controller::Table,
+                                     Controller::Group, Controller::Grouping ]
 
     # Hook for setting available options using a template. See the template 
     # documentation for the available options and their format.
@@ -94,14 +94,7 @@ module Ruport
 
       calculate_max_col_widths unless options.max_col_width
 
-      render_data_by_row do |rend|
-        rend.options do |o|
-          o.max_col_width = options.max_col_width
-          o.alignment     = options.alignment
-          o.table_width   = options.table_width   
-          o.ignore_table_width = options.ignore_table_width
-        end
-      end
+      data.each { |row| build_row(row) }
 
       output << fit_to_width(hr)
     end
@@ -114,7 +107,7 @@ module Ruport
     #
     # Uses fit_to_width to truncate the row if necessary.
     #
-    def build_row
+    def build_row(data = self.data)
       max_col_widths_for_row(data) unless options.max_col_width
 
       data.enum_for(:each_with_index).inject(line=[]) { |s,e|
@@ -136,14 +129,14 @@ module Ruport
     end
     
     # Creates the group body. Since group data is a table, just uses the
-    # Table renderer.
+    # Table controller.
     #
     def build_group_body
       render_table data, options
     end
 
     # Generates the body for a grouping. Iterates through the groups and
-    # renders them using the group renderer.
+    # renders them using the group controller.
     #
     def build_grouping_body
       render_inline_grouping(options)
@@ -170,7 +163,7 @@ module Ruport
     #
     # Otherwise, uses SystemExtensions to determine terminal width.
     def width
-      options.table_width || SystemExtensions.terminal_width
+      options.table_width ||= SystemExtensions.terminal_width
     end
 
     # Truncates a string so that it does not exceed Text#width

data/test/{renderer_test.rb → controller_test.rb}

@@ -14,11 +14,11 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 #============================================================================
 # These two renderers represent the two styles that can be used when defining
-# renderers in Ruport.  The OldSchoolRenderer approach has largely been
+# renderers in Ruport.  The OldSchoolController approach has largely been
 # deprecated, but still has uses in edge cases that we need to support.
 #============================================================================
 
-class OldSchoolRenderer < Ruport::Renderer
+class OldSchoolController < Ruport::Controller
 
   def run
     formatter do
@@ -30,7 +30,7 @@ class OldSchoolRenderer < Ruport::Renderer
 
 end               
 
-class VanillaRenderer < Ruport::Renderer
+class VanillaController < Ruport::Controller
   stage :header,:body,:footer
 end
 
@@ -40,7 +40,7 @@ end
 # be replaced by mock objects in the future.
 class DummyText < Ruport::Formatter
   
-  renders :text, :for => OldSchoolRenderer
+  renders :text, :for => OldSchoolController
   
   def prepare_document
     output << "p"
@@ -63,22 +63,54 @@ class DummyText < Ruport::Formatter
   end
 end   
 
+# This formatter modifies the (String) data object passed to it
+class Destructive < Ruport::Formatter
+
+  def prepare_document; end
+
+  def build_header; end
+
+  def build_body
+    output << "You sent #{data}"
+    data.replace("RUBBISH")
+  end
+
+  def build_footer; end
+
+  def finalize_document; end
+end
+
+
 class VanillaBinary < Ruport::Formatter
-  renders :bin, :for => VanillaRenderer
+  renders :bin, :for => VanillaController
   save_as_binary_file
-end
+end 
 
+class SpecialFinalize < Ruport::Formatter
+  renders :with_finalize, :for => VanillaController
+  
+  def finalize
+    output << "I has been finalized"
+  end
+end
 
-class TestRenderer < Test::Unit::TestCase
+class TestController < Test::Unit::TestCase
 
   def teardown
     Ruport::Formatter::Template.instance_variable_set(:@templates, nil)
   end
 
   def test_trivial
-    actual = OldSchoolRenderer.render(:text)
+    actual = OldSchoolController.render(:text)
     assert_equal "header\nbody\nfooter\n", actual
-  end    
+  end          
+  
+  context "when running a formatter with custom a finalize method" do
+    def specify_finalize_method_should_be_called
+      assert_equal "I has been finalized", 
+                   VanillaController.render_with_finalize
+    end                
+  end
   
   context "when using templates" do
     def specify_apply_template_should_be_called
@@ -124,7 +156,7 @@ class TestRenderer < Test::Unit::TestCase
   def test_using_io
     require "stringio"
     out = StringIO.new
-    a = OldSchoolRenderer.render(:text) { |r| r.io = out }
+    a = OldSchoolController.render(:text) { |r| r.io = out }
     out.rewind
     assert_equal "header\nbody\nfooter\n", out.read
     assert_equal "", out.read
@@ -133,12 +165,12 @@ class TestRenderer < Test::Unit::TestCase
   def test_using_file
     f = []
     File.expects(:open).yields(f)
-    a = OldSchoolRenderer.render(:text, :file => "foo.text")
+    a = OldSchoolController.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")        
+    VanillaController.render(:bin, :file => "blah")        
   end       
   
   def test_using_file_via_rendering_tools     
@@ -150,25 +182,25 @@ class TestRenderer < Test::Unit::TestCase
     
 
   def test_formats
-    assert_equal( {}, Ruport::Renderer.formats )
-    assert_equal( { :text => DummyText },OldSchoolRenderer.formats )
+    assert_equal( {}, Ruport::Controller.formats )
+    assert_equal( { :text => DummyText },OldSchoolController.formats )
   end
 
   def test_method_missing
-    actual = OldSchoolRenderer.render_text
+    actual = OldSchoolController.render_text
     assert_equal "header\nbody\nfooter\n", actual
   end
 
   def test_formatter
     # normal instance mode
-    rend = OldSchoolRenderer.new
+    rend = OldSchoolController.new
     rend.send(:use_formatter,:text)
 
     assert_kind_of Ruport::Formatter, rend.formatter
     assert_kind_of DummyText, rend.formatter
 
     # render mode
-    OldSchoolRenderer.render_text do |r|
+    OldSchoolController.render_text do |r|
       assert_kind_of Ruport::Formatter, r.formatter
       assert_kind_of DummyText, r.formatter
     end
@@ -180,7 +212,7 @@ class TestRenderer < Test::Unit::TestCase
   end  
   
   def test_options_act_like_indifferent_hash
-     opts = Ruport::Renderer::Options.new
+     opts = Ruport::Controller::Options.new
      opts.foo = "bar"
      assert_equal "bar", opts[:foo]
      assert_equal "bar", opts["foo"]    
@@ -202,7 +234,7 @@ end
 class TestFormatterUsingBuild < Test::Unit::TestCase
   # This formatter uses the build syntax
   class UsesBuild < Ruport::Formatter
-     renders :text_using_build, :for => VanillaRenderer 
+     renders :text_using_build, :for => VanillaController 
      
      build :header do
        output << "header\n"
@@ -219,8 +251,8 @@ class TestFormatterUsingBuild < Test::Unit::TestCase
 
   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|
+      VanillaController.render_text_using_build
+    VanillaController.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)
@@ -233,7 +265,7 @@ 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
   class WithLayout < DummyText
-     renders :text_with_layout, :for => VanillaRenderer 
+     renders :text_with_layout, :for => VanillaController 
      
      def layout     
        output << "---\n"
@@ -245,21 +277,22 @@ class TestFormatterWithLayout < Test::Unit::TestCase
 
   def test_layout
      assert_equal "---\nheader\nbody\nfooter\n---\n", 
-                  VanillaRenderer.render_text_with_layout
+                  VanillaController.render_text_with_layout
   end
   
   def test_layout_disabled
      assert_equal "header\nbody\nfooter\n",
-                  VanillaRenderer.render_text_with_layout(:layout => false)
+                  VanillaController.render_text_with_layout(:layout => false)
   end
 
 end
 
 
-class TestRendererWithManyHooks < Test::Unit::TestCase
-  # This provides a way to check several hooks that Renderer supports
-  class RendererWithManyHooks < Ruport::Renderer
+class TestControllerWithManyHooks < Test::Unit::TestCase
+  # This provides a way to check several hooks that controllers supports
+  class ControllerWithManyHooks < Ruport::Controller
     add_format DummyText, :text
+    add_format Destructive, :destructive
 
     prepare :document
 
@@ -276,7 +309,7 @@ class TestRendererWithManyHooks < Test::Unit::TestCase
   end
 
   def test_hash_options_setters
-    a = RendererWithManyHooks.render(:text, :subtitle => "foo",
+    a = ControllerWithManyHooks.render(:text, :subtitle => "foo",
                                        :subsubtitle => "bar") { |r|
       assert_equal "foo", r.options.subtitle
       assert_equal "bar", r.options.subsubtitle
@@ -284,54 +317,61 @@ class TestRendererWithManyHooks < Test::Unit::TestCase
   end
 
   def test_data_accessors
-   a = RendererWithManyHooks.render(:text, :data => [1,2,4]) { |r|
+   a = ControllerWithManyHooks.render(:text, :data => [1,2,4]) { |r|
      assert_equal [1,2,4], r.data
    }
   
-   b = RendererWithManyHooks.render_text(%w[a b c]) { |r|
+   b = ControllerWithManyHooks.render_text(%w[a b c]) { |r|
      assert_equal %w[a b c], r.data
    }
   
-   c = RendererWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r|
+   c = ControllerWithManyHooks.render_text(%w[a b f],:snapper => :red) { |r|
      assert_equal %w[a b f], r.data
      assert_equal :red, r.options.snapper
    }
   end
 
+  def test_formatter_data_dup
+    source = "some text"
+    result = ControllerWithManyHooks.render(:destructive, :data => source)
+    assert_equal("You sent some text", result)
+    assert_equal("some text", source)
+  end
+
   def test_stage_helper
-    assert RendererWithManyHooks.stages.include?('body')
+    assert ControllerWithManyHooks.stages.include?('body')
   end
  
   def test_finalize_helper
-    assert_equal :document, RendererWithManyHooks.final_stage
+    assert_equal :document, ControllerWithManyHooks.final_stage
   end
 
   def test_prepare_helper
-   assert_equal :document, RendererWithManyHooks.first_stage
+   assert_equal :document, ControllerWithManyHooks.first_stage
   end
 
   def test_finalize_again
-   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
-     RendererWithManyHooks.finalize :report 
+   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+     ControllerWithManyHooks.finalize :report 
    }
   end
 
   def test_prepare_again
-   assert_raise(Ruport::Renderer::StageAlreadyDefinedError) { 
-     RendererWithManyHooks.prepare :foo 
+   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+     ControllerWithManyHooks.prepare :foo 
    }
   end
 
   def test_renderer_using_helpers
-   actual = RendererWithManyHooks.render(:text)
+   actual = ControllerWithManyHooks.render(:text)
    assert_equal "pheader\nbody\nfooter\nf", actual
 
-   actual = RendererWithManyHooks.render_text
+   actual = ControllerWithManyHooks.render_text
    assert_equal "pheader\nbody\nfooter\nf", actual
   end
 
   def test_required_option_helper
-   a = RendererWithManyHooks.dup
+   a = ControllerWithManyHooks.dup
    a.required_option :title
 
    a.render_text do |r|
@@ -342,18 +382,18 @@ class TestRendererWithManyHooks < Test::Unit::TestCase
   end
 
   def test_without_required_option
-   a = RendererWithManyHooks.dup
+   a = ControllerWithManyHooks.dup
    a.required_option :title
 
-   assert_raise(Ruport::Renderer::RequiredOptionNotSet) { a.render(:text) }
+   assert_raise(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
   end
  
 end
 
 
-class TestRendererWithRunHook < Test::Unit::TestCase
+class TestControllerWithRunHook < Test::Unit::TestCase
 
-  class RendererWithRunHook < Ruport::Renderer
+  class ControllerWithRunHook < Ruport::Controller
     add_format DummyText, :text
 
     required_option :foo,:bar
@@ -370,15 +410,15 @@ class TestRendererWithRunHook < Test::Unit::TestCase
 
   def test_renderer_with_run_hooks
     assert_equal "|header\nbody\nfooter\n", 
-       RendererWithRunHook.render_text(:foo => "bar",:bar => "baz")
+       ControllerWithRunHook.render_text(:foo => "bar",:bar => "baz")
   end
 
 end
 
 
-class TestRendererWithHelperModule < Test::Unit::TestCase
+class TestControllerWithHelperModule < Test::Unit::TestCase
 
-  class RendererWithHelperModule < VanillaRenderer
+  class ControllerWithHelperModule < VanillaController
 
     add_format DummyText, :stub
 
@@ -390,7 +430,7 @@ class TestRendererWithHelperModule < Test::Unit::TestCase
   end   
 
   def test_renderer_helper_module
-    RendererWithHelperModule.render_stub do |r|
+    ControllerWithHelperModule.render_stub do |r|
       assert_equal "Hello Dolly", r.formatter.say_hello
     end
   end
@@ -398,10 +438,10 @@ end
 
 
 class TestMultiPurposeFormatter < Test::Unit::TestCase
-  # This provides a way to check the multi-format hooks for the Renderer
+  # This provides a way to check the multi-format hooks for the Controller
   class MultiPurposeFormatter < Ruport::Formatter 
 
-     renders [:html,:text], :for => VanillaRenderer
+     renders [:html,:text], :for => VanillaController
 
      def build_header
        a = 10
@@ -419,9 +459,9 @@ class TestMultiPurposeFormatter < Test::Unit::TestCase
   end   
 
   def test_multi_purpose
-    text = VanillaRenderer.render_text(:body_text => "foo")
+    text = VanillaController.render_text(:body_text => "foo")
     assert_equal "Foo: 10\nfoo", text
-    html = VanillaRenderer.render_html(:body_text => "bar")
+    html = VanillaController.render_html(:body_text => "bar")
     assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html
   end
 
@@ -452,7 +492,7 @@ end
 class TestFormatterErbHelper < Test::Unit::TestCase
   class ErbFormatter < Ruport::Formatter
      
-    renders :terb, :for  => VanillaRenderer
+    renders :terb, :for  => VanillaController
     
     def build_body    
        # demonstrate local binding
@@ -470,25 +510,25 @@ class TestFormatterErbHelper < Test::Unit::TestCase
    #FIXME: need to test file
 
    def test_self_bound
-     assert_equal "Default Binding: bar", VanillaRenderer.render_terb
+     assert_equal "Default Binding: bar", VanillaController.render_terb
    end
    
    def test_custom_bound
      a = [1,2,3]
      arr_binding = a.instance_eval { binding }
      assert_equal "Binding Override: 321", 
-                   VanillaRenderer.render_terb(:binding => arr_binding)
+                   VanillaController.render_terb(:binding => arr_binding)
    end
 end    
 
 
 class TestOptionReaders < Test::Unit::TestCase
   
-  class RendererForCheckingOptionReaders < Ruport::Renderer
+  class ControllerForCheckingOptionReaders < Ruport::Controller
     required_option :foo  
   end 
   
-  class RendererForCheckingPassivity < Ruport::Renderer
+  class ControllerForCheckingPassivity < Ruport::Controller
     def foo
       "apples"
     end
@@ -496,10 +536,10 @@ class TestOptionReaders < Test::Unit::TestCase
   end
 
    def setup 
-     @renderer = RendererForCheckingOptionReaders.new 
+     @renderer = ControllerForCheckingOptionReaders.new 
      @renderer.formatter = Ruport::Formatter.new 
      
-     @passive = RendererForCheckingPassivity.new
+     @passive = ControllerForCheckingPassivity.new
      @passive.formatter = Ruport::Formatter.new
    end
    
@@ -519,7 +559,7 @@ end
      
 class TestSetupOrdering < Test::Unit::TestCase
    
-  class RendererWithSetup < Ruport::Renderer
+  class ControllerWithSetup < Ruport::Controller
     stage :bar
     def setup
       options.foo.capitalize!
@@ -527,7 +567,7 @@ class TestSetupOrdering < Test::Unit::TestCase
   end           
   
   class BasicFormatter < Ruport::Formatter 
-    renders :text, :for => RendererWithSetup
+    renders :text, :for => ControllerWithSetup
     
     def build_bar
       output << options.foo
@@ -535,24 +575,89 @@ 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", ControllerWithSetup.render_text(:foo => "hello")
   end       
   
   def test_render_block_should_be_called_before_setup
     assert_equal "Hello", 
-      RendererWithSetup.render_text { |r| r.options.foo = "hello" }
+      ControllerWithSetup.render_text { |r| r.options.foo = "hello" }
   end
   
 end
 
-class TestRendererHooks < Test::Unit::TestCase
+class CustomFormatter < Ruport::Formatter
+  def custom_helper
+    output << "Custom!"
+  end
+end
+
+class ControllerWithAnonymousFormatters < Ruport::Controller
+
+  stage :report
+
+  formatter :html do
+    build :report do
+      output << textile("h1. Hi there")
+    end
+  end
+
+  formatter :csv do
+    build :report do
+      build_row([1,2,3])
+    end
+  end
+
+  formatter :pdf do
+    build :report do 
+      add_text "hello world"
+    end
+  end
+
+  formatter :text do
+    build :report do
+      output << "Hello world"
+    end
+  end
+
+  formatter :custom => CustomFormatter do
+
+    build :report do
+      output << "This is "
+      custom_helper
+    end
+
+  end
+
+end
+
+class TestAnonymousFormatter < Test::Unit::TestCase
+  context "When using built in Ruport formatters" do
+
+    def specify_text_formatter_shortcut_is_accessible
+      assert_equal "Hello world", ControllerWithAnonymousFormatters.render_text
+      assert_equal "1,2,3\n", ControllerWithAnonymousFormatters.render_csv
+      assert_equal "<h1>Hi there</h1>", ControllerWithAnonymousFormatters.render_html
+      assert_not_nil ControllerWithAnonymousFormatters.render_pdf
+    end
+    
+  end
+
+  context "When using custom formatters" do
+    def specify_custom_formatter_shortcut_is_accessible
+      assert_equal "This is Custom!", ControllerWithAnonymousFormatters.render_custom
+    end
+  end
+
+end
+
+class TestControllerHooks < Test::Unit::TestCase
 
   context "when renderable_data omitted" do
 
     require "mocha"
 
     class DummyObject 
-      include Ruport::Renderer::Hooks
+      include Ruport::Controller::Hooks
       renders_as_table
     end
 
@@ -560,7 +665,7 @@ class TestRendererHooks < Test::Unit::TestCase
       a = DummyObject.new
       rend = mock("renderer")
       rend.expects(:data=).with(a)
-      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
       a.as(:csv)
     end
 
@@ -569,7 +674,7 @@ class TestRendererHooks < Test::Unit::TestCase
   context "when using renderable_data" do
 
     class DummyObject2
-      include Ruport::Renderer::Hooks
+      include Ruport::Controller::Hooks
       renders_as_table
 
       def renderable_data(format)
@@ -581,12 +686,12 @@ class TestRendererHooks < Test::Unit::TestCase
       a = DummyObject2.new
       rend = mock("renderer")
       rend.expects(:data=).with(1)
-      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
       a.as(:csv)
     end
 
     class DummyObject3
-      include Ruport::Renderer::Hooks
+      include Ruport::Controller::Hooks
       renders_as_table
       
       def renderable_data
@@ -599,7 +704,7 @@ class TestRendererHooks < Test::Unit::TestCase
     end
 
     class DummyObject4
-      include Ruport::Renderer::Hooks
+      include Ruport::Controller::Hooks
       renders_as_table
 
       def renderable_data(format)
@@ -616,7 +721,7 @@ class TestRendererHooks < Test::Unit::TestCase
       a = DummyObject4.new
       rend = mock("renderer")
       rend.expects(:data=).with(2)
-      Ruport::Renderer::Table.expects(:render).with(:csv,{}).yields(rend)
+      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
       a.as(:csv)
     end
 
@@ -626,8 +731,8 @@ class TestRendererHooks < Test::Unit::TestCase
 
     def specify_an_unknown_format_error_should_be_raised
 
-      assert_raises(Ruport::Renderer::UnknownFormatError) do
-        Ruport::Renderer.render_foo
+      assert_raises(Ruport::Controller::UnknownFormatError) do
+        Ruport::Controller.render_foo
       end
 
     end