ruport 1.4.0 → 1.6.0

data/Rakefile

@@ -2,7 +2,7 @@ require "rake/rdoctask"
 require "rake/testtask"
 require "rake/gempackagetask"
 
-RUPORT_VERSION = "1.4.0"
+RUPORT_VERSION = "1.6.0"
 
 begin
   require "rubygems"
@@ -32,8 +32,8 @@ spec = Gem::Specification.new do |spec|
   spec.extra_rdoc_files = %w{README LICENSE AUTHORS}
   spec.rdoc_options << '--title' << 'Ruport Documentation' <<
                        '--main'  << 'README' << '-q'
-  spec.add_dependency('fastercsv', '>= 1.1.0')
-  spec.add_dependency('pdf-writer', '= 1.1.7')
+  spec.add_dependency('fastercsv', '= 1.2.3')
+  spec.add_dependency('pdf-writer','= 1.1.8')
   spec.author = "Gregory Brown"
   spec.email = "  gregory.t.brown@gmail.com"
   spec.rubyforge_project = "ruport"

data/examples/anon.rb

@@ -0,0 +1,43 @@
+# Demonstrates building a parent controller which provides additional 'built in'
+# formats, allowing anonymous formatter support to use the simple interface
+# rather than the :format => FormatterClass approach.
+
+require "ruport"
+module FooCorp
+  class Controller < Ruport::Controller
+    def self.built_in_formats
+      super.merge(:xml => FooCorp::Formatter::XML)
+    end
+  end
+
+  class Formatter
+    class XML < Ruport::Formatter
+
+      def xmlify(stuff)
+        output << "Wouldn't you like to see #{stuff} in XML?"
+      end
+    end
+  end
+
+  class MyController < FooCorp::Controller
+    stage :foo
+
+    formatter :xml do
+      build :foo do
+        xmlify "Red Snapper"
+      end
+    end
+
+    formatter :text do
+      build :foo do
+        output << "Red Snapper"
+      end
+    end
+  end
+end
+
+puts "XML:"
+puts FooCorp::MyController.render_xml
+
+puts "Text:"
+puts FooCorp::MyController.render_text

data/examples/btree/commaleon/commaleon.rb

@@ -10,7 +10,7 @@
 # of CSV dumps to see what has been removed or altered (we don't care
 # about new records )
 #
-# It's a camping app, but the core of it is a renderer/formatter combo. 
+# It's a camping app, but the core of it is a controller/formatter combo. 
 # (Marked by %%%%%%%%%%% below)     
 #
 # You'll need the camping omnibus and the F() ruport plugin to run this app.
@@ -51,13 +51,13 @@ module Commaleon::Helpers
 
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 # This is the bulk of the Ruport code in this app
-# (CSVDiffRenderer and CSVDiffFormatter)
+# (CSVDiffController and CSVDiffFormatter)
 # The rest is just camping.  The interesting thing here is that
 # you could easily define these in another file and just require
 # them here, and use them standalone outside of your web app.      
 # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-  class CSVDiffRenderer < Ruport::Renderer
+  class CSVDiffController < Ruport::Controller
      stage :diff_report
      option :key, :mcsv, :ccsv  
       
@@ -65,7 +65,7 @@ module Commaleon::Helpers
      # manipulations on the data and options before handing off the 
      # rendering task to the formatters.
      #   
-     # We're using grouping mainly for the renderer support,
+     # We're using grouping mainly for the controller support,
      # and rather than reducing a table, we're building up the
      # group objects via the helper methods missing_from_compare
      # and different_from_compare
@@ -133,7 +133,7 @@ module Commaleon::Helpers
   #
   # http://stonecode.svnrepository.com/ruport/trac.cgi/wiki/F
   #
-  class CSVDiffFormatter < F([:html,:text,:csv,:pdf], :for => CSVDiffRenderer)
+  class CSVDiffFormatter < F([:html,:text,:csv,:pdf], :for => CSVDiffController)
     def build_diff_report        
      # this is using the selective blocks for formatters that implement
      # more than one format.  The block below will only be called when this
@@ -183,7 +183,7 @@ module Commaleon::Controllers
     
     def post
       @state.key = @input.csv_id  
-      @table = CSVDiffRenderer.render_html(:key =>  @state.key,
+      @table = CSVDiffController.render_html(:key =>  @state.key,
                                            :mcsv => @state.mfile,
                                            :ccsv => @state.cfile )  
       render :html_diff   
@@ -207,11 +207,11 @@ module Commaleon::Controllers
        set_headers(format)                        
        case(format)
        when "csv"
-         text CSVDiffRenderer.render_csv(options)  
+         text CSVDiffController.render_csv(options)  
        when "pdf"
-         text CSVDiffRenderer.render_pdf(options.merge(:style => :justified)) 
+         text CSVDiffController.render_pdf(options.merge(:style => :justified)) 
        when "txt"
-         text CSVDiffRenderer.render_text(options)
+         text CSVDiffController.render_text(options)
        else
          text "no format!"
        end                                

data/examples/centered_pdf_text_box.rb

@@ -1,21 +1,21 @@
 require "ruport"                             
  
-# Renderers can be though of as control classes or interface builders.
+# Controllers can be though of as control classes or interface builders.
 # Essentially, they define the options that formatters should implement
 # and the stages of rendering they should handle.  Ruport's formatting
-# system is very forgiving, and the renderers do not force their
+# system is very forgiving, and the controllers do not force their
 # specs onto formatters that are attached to them. 
 #
-class Document < Ruport::Renderer
+class Document < Ruport::Controller
   
   # Will throw an error if these options are not set at rendering time
   required_option :text, :author                                      
   
-  # The renderer will look for a build_document_body() method on the formatter,
+  # The controller will look for a build_document_body() method on the formatter,
   # but silently skip this stage if it is missing
   stage :document_body
   
-  # The renderer will look for a finalize_document() method on the formatter,
+  # The controller will look for a finalize_document() method on the formatter,
   # but silently skip this stage if it is missing
   finalize :document                            
 end
@@ -59,11 +59,11 @@ class CenteredPDFTextBox < Ruport::Formatter::PDF
   end
 end
 
-# All options passed to a renderer will be written onto the options object.
+# All options passed to a controller will be written onto the options object.
 # In the block form, you may use explicit accessors 
 # (i.e. r.text instead of r.options.text ) for only things that have
 # either been defined with option / required_option methods, 
-# or have explicit accessors in the Renderer.
+# or have explicit accessors in the Controller.
 #
 a = Document.render_pdf( :heading => "a good quote", 
                          :author => "Ralph Waldo Emerson") do |r|

data/examples/line_plotter.rb

@@ -1,6 +1,6 @@
 require "ruport"
 
-class LinePlotter < Ruport::Renderer
+class LinePlotter < Ruport::Controller
 
    options do |o|
     o.line_color   = "green"

data/examples/pdf_report_with_common_base.rb

@@ -8,14 +8,14 @@
                          
 require "ruport" 
 
-# only used for the titleize call in ClientRenderer#setup  
+# only used for the titleize call in ClientController#setup  
 # tweak as needed if you don't want to install AS.
 require "active_support" 
 
 # This looks a little more messy than usual, but it addresses the
 # concern of wanting to have a standard template for reports.
 #
-class ClientRenderer < Ruport::Renderer
+class ClientController < Ruport::Controller
   prepare :standard_report
   stage :company_header, :client_header, :client_body, :client_footer
   finalize :standard_report
@@ -51,7 +51,7 @@ end
 #  Notice the footer is not implemented and it doesn't complain.   
 #
 class ClientPDF < CompanyPDFBase
-  renders :pdf, :for => ClientRenderer
+  renders :pdf, :for => ClientController
 
   def build_client_header
    pad(10) do
@@ -68,5 +68,5 @@ end
 table = Table([:a,:b,:c]) << [1,2,3] << [4,5,6]
 
 File.open("example.pdf","w") do |f|
-  f << ClientRenderer.render_pdf(:data => table,:example => "apple")
+  f << ClientController.render_pdf(:data => table,:example => "apple")
 end

data/examples/png_embed.rb

@@ -1,14 +1,14 @@
 require "rubygems"
 require "ruport"
 
-class RoadmapRenderer < Ruport::Renderer
+class RoadmapController < Ruport::Controller
   stage :roadmap_image, :roadmap_text_body
   finalize :roadmap
 end
 
 class HTMLRoadmap < Ruport::Formatter
 
-  renders :html, :for => RoadmapRenderer
+  renders :html, :for => RoadmapController
 
   def layout
      output << "<html><body>\n"
@@ -28,7 +28,7 @@ end
 
 class PDFRoadmap < Ruport::Formatter::PDF
 
-  renders :pdf, :for => RoadmapRenderer
+  renders :pdf, :for => RoadmapController
 
   def build_roadmap_image
     center_image_in_box options.image_file, :x => 0, :y => 200, 
@@ -49,6 +49,6 @@ end
 
 formats = [:html, :pdf]
 formats.each do  |format|
-  RoadmapRenderer.render(format, :image_file => "roadmap.png", 
+  RoadmapController.render(format, :image_file => "roadmap.png", 
                                  :file => "roadmap.#{format}")
 end

data/examples/row_renderer.rb

@@ -1,12 +1,12 @@
 require "ruport"
 
-class CSV2Something < Ruport::Renderer
-  required_option :file
+class CSV2Something < Ruport::Controller
+  required_option :csv_file
   stage :table_body
 
   module Helpers
     def table_feeder
-      Table(options.file,:has_names => false) { |t,r| yield(r) }
+      Table(options.csv_file,:has_names => false) { |t,r| yield(r) }
     end
   end
 
@@ -36,4 +36,4 @@ class Text < Ruport::Formatter::Text
  
 end
 
-CSV2Something.render_html(:file => "example.csv",:io => STDOUT)
+CSV2Something.render_html(:csv_file => "example.csv",:io => STDOUT)

data/examples/simple_pdf_lines.rb

@@ -2,7 +2,7 @@ require "ruport"
 
 # draws pretty little lines all over the place on a PDF
 
-class SimpleLines < Ruport::Renderer
+class SimpleLines < Ruport::Controller
   stage :horizontal_lines
 end
 

data/examples/trac_ticket_status.rb

@@ -2,7 +2,7 @@
 
 class TracSummaryReport
   
-  include Ruport::Renderer::Hooks
+  include Ruport::Controller::Hooks
   
   renders_as_table
   

data/lib/ruport.rb

@@ -9,11 +9,23 @@
 #
 # See LICENSE and COPYING for details
 #
+ 
+
+if RUBY_VERSION > "1.9"     
+  require "csv"   
+  unless defined? FCSV
+    class Object   
+      FCSV = CSV  
+      alias_method :FCSV, :CSV 
+    end   
+  end
+end
+
 
 module Ruport #:nodoc:#
   
-  VERSION = "1.4.0"   
-  
+  VERSION = "1.6.0"     
+ 
   class FormatterError < RuntimeError #:nodoc:
   end
   
@@ -102,7 +114,7 @@ module Ruport #:nodoc:#
 end  
 
 require "enumerator"
-require "ruport/renderer" 
+require "ruport/controller" 
 require "ruport/data" 
 require "ruport/formatter" 
 

data/lib/ruport/{renderer.rb → controller.rb}

@@ -1,16 +1,16 @@
-# renderer.rb : General purpose formatted data renderer for Ruby Reports
+# controller.rb : General purpose control of formatted data for Ruby Reports
 #
 # Copyright December 2006, Gregory Brown.  All Rights Reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 
-# This class implements the core renderer for Ruport's formatting system.  It is
-# designed to implement the low level tools necessary to build report renderers
-# for different kinds of tasks.  See Renderer::Table for a tabular data
-# renderer.  
+# This class implements the core controller for Ruport's formatting system.
+# It is designed to implement the low level tools necessary to build report
+# controllers for different kinds of tasks.  See Controller::Table for a
+# tabular data controller.  
 #
-class Ruport::Renderer
+class Ruport::Controller
   
   class RequiredOptionNotSet < RuntimeError #:nodoc:
   end
@@ -18,16 +18,18 @@ class Ruport::Renderer
   end
   class StageAlreadyDefinedError < RuntimeError #:nodoc: 
   end
-  class RendererNotSetError < RuntimeError #:nodoc:
+  class ControllerNotSetError < RuntimeError #:nodoc:
   end
                                           
   require "ostruct"              
   
-  # Structure for holding renderer options.  
+  # Structure for holding controller options.  
   # Simplified version of HashWithIndifferentAccess
   class Options < OpenStruct 
-    
-    private :id
+           
+    if RUBY_VERSION < "1.9"
+      private :id   
+    end
     
     # Returns a Hash object.  Use this if you need methods other than []
     def to_hash
@@ -57,23 +59,23 @@ class Ruport::Renderer
   # structures, as well as the renders_with and renders_as_* helpers.
   #
   # You can actually use this with any data structure, it will look for a
-  # renderable_data(format) method to pass to the <tt>renderer</tt> you 
+  # renderable_data(format) method to pass to the <tt>controller</tt> you 
   # specify, but if that is not defined, it will pass <tt>self</tt>.
   #
   # Examples:
   #
-  #   # Render Arrays with Ruport's Row Renderer
+  #   # Render Arrays with Ruport's Row Controller
   #   class Array
-  #     include Ruport::Renderer::Hooks
+  #     include Ruport::Controller::Hooks
   #     renders_as_row
   #   end
   #
   #   # >> [1,2,3].as(:csv) 
   #   # => "1,2,3\n" 
   #
-  #   # Render Hashes with Ruport's Row Renderer
+  #   # Render Hashes with Ruport's Row Controller
   #   class Hash
-  #      include Ruport::Renderer::Hooks
+  #      include Ruport::Controller::Hooks
   #      renders_as_row
   #      attr_accessor :column_order
   #      def renderable_data(format)
@@ -88,24 +90,24 @@ class Ruport::Renderer
   module Hooks 
     module ClassMethods 
       
-      # Tells the class which renderer as() will forward to.
+      # Tells the class which controller as() will forward to.
       #
       # Usage:
       #
       #   class MyStructure
-      #     include Renderer::Hooks
-      #     renders_with CustomRenderer
+      #     include Controller::Hooks
+      #     renders_with CustomController
       #   end
       #   
       # You can also specify default rendering options, which will be used
       # if they are not overriden by the options passed to as().
       #
       #   class MyStructure
-      #     include Renderer::Hooks
-      #     renders_with CustomRenderer, :font_size => 14
+      #     include Controller::Hooks
+      #     renders_with CustomController, :font_size => 14
       #   end
-      def renders_with(renderer,opts={})
-        @renderer = renderer.name
+      def renders_with(controller,opts={})
+        @controller = controller
         @rendering_options=opts
       end  
       
@@ -114,39 +116,38 @@ class Ruport::Renderer
         @rendering_options
       end
        
-      # Shortcut for renders_with(Ruport::Renderer::Table), you
-      # may wish to override this if you build a custom table renderer.
+      # Shortcut for renders_with(Ruport::Controller::Table), you
+      # may wish to override this if you build a custom table controller.
       def renders_as_table(options={})
-        renders_with Ruport::Renderer::Table,options
+        renders_with Ruport::Controller::Table,options
       end
       
-      # Shortcut for renders_with(Ruport::Renderer::Row), you
-      # may wish to override this if you build a custom row renderer. 
+      # Shortcut for renders_with(Ruport::Controller::Row), you
+      # may wish to override this if you build a custom row controller. 
       def renders_as_row(options={})
-        renders_with Ruport::Renderer::Row, options
+        renders_with Ruport::Controller::Row, options
       end
       
-      # Shortcut for renders_with(Ruport::Renderer::Group), you
-      # may wish to override this if you build a custom group renderer.  
+      # Shortcut for renders_with(Ruport::Controller::Group), you
+      # may wish to override this if you build a custom group controller.  
       def renders_as_group(options={})
-        renders_with Ruport::Renderer::Group,options
+        renders_with Ruport::Controller::Group,options
       end 
       
-      # Shortcut for renders_with(Ruport::Renderer::Grouping), you
-      # may wish to override this if you build a custom grouping renderer.
+      # Shortcut for renders_with(Ruport::Controller::Grouping), you
+      # may wish to override this if you build a custom grouping controller.
       def renders_as_grouping(options={})
-        renders_with Ruport::Renderer::Grouping,options
+        renders_with Ruport::Controller::Grouping,options
       end
       
-      # The class of the renderer object for the base class.
+      # The class of the controller object for the base class.
       #
       # Example:
       # 
-      #   >> Ruport::Data::Table.renderer
-      #   => Ruport::Renderer::Table
-      def renderer
-        return unless @renderer
-        @renderer.split("::").inject(Class) { |c,el| c.const_get(el) }
+      #   >> Ruport::Data::Table.controller
+      #   => Ruport::Controller::Table
+      def controller
+        @controller
       end
     end
 
@@ -154,22 +155,22 @@ class Ruport::Renderer
       base.extend(ClassMethods)
     end      
     
-    # Uses the Renderer specified by renders_with to generate formatted
+    # Uses the Controller specified by renders_with to generate formatted
     # output.  Passes the return value of the <tt>renderable_data(format)</tt>
     # method if the method is defined, otherwise passes <tt>self</tt> as :data
     #
-    # The remaining options are converted to a Renderer::Options object and
-    # are accessible in both the renderer and formatter.
+    # The remaining options are converted to a Controller::Options object and
+    # are accessible in both the controller and formatter.
     #
     #  Example:
     #
     #    table.as(:csv, :show_table_headers => false)
     def as(format,options={})
-      raise RendererNotSetError unless self.class.renderer
-      unless self.class.renderer.formats.include?(format)
+      raise ControllerNotSetError unless self.class.controller
+      unless self.class.controller.formats.include?(format)
         raise UnknownFormatError
       end
-      self.class.renderer.render(format,
+      self.class.controller.render(format,
         self.class.rendering_options.merge(options)) do |rend|
           rend.data =
             respond_to?(:renderable_data) ? renderable_data(format) : self
@@ -183,9 +184,105 @@ class Ruport::Renderer
       as(format.to_sym, options.merge(:file => file))        
     end
   end
+
   
   
   class << self
+
+    # Returns a hash that maps format names to their formatter classes, for use
+    # with the formatter shortcut.  Supported formats are :html, :csv, :pdf, and
+    # :text by default.
+    #
+    #
+    # Sample override:
+    #
+    #   class MyController < Ruport::Controller
+    # 
+    #     def built_in_formats
+    #       super.extend(:xml => MyXMLFormatter,
+    #                    :json => MyJSONFormatter)
+    #     end
+    #   end 
+    #
+    # This would allow for:
+    #
+    #   class ChildController < MyController
+    #
+    #     formatter :xml do
+    #       # ...
+    #     end
+    #
+    #     formatter :json do
+    #       # ...
+    #     end
+    #   end
+    #     
+    def built_in_formats
+     { :html => Ruport::Formatter::HTML,
+       :csv  => Ruport::Formatter::CSV,
+       :pdf  => Ruport::Formatter::PDF,
+       :text => Ruport::Formatter::Text }
+    end
+
+
+    # Generates an anonymous formatter class and ties it to the Controller.
+    # This method looks up the built in formats in the hash returned by 
+    # built_in_formats, but also explicitly specify a custom Formatter class to
+    # subclass from.
+    #
+    # Sample usage:
+    #
+    #   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
+    #
+    def formatter(*a,&b)
+      case a[0]
+      when Symbol
+        klass = Class.new(built_in_formats[a[0]])
+        klass.renders a[0], :for => self
+      when Hash
+        k,v = a[0].to_a[0]
+        klass = Class.new(v)
+        klass.renders k, :for => self
+      end
+      klass.class_eval(&b)
+    end
     
     attr_accessor :first_stage,:final_stage,:required_options,:stages #:nodoc: 
     
@@ -194,18 +291,18 @@ class Ruport::Renderer
     #
     # Usage:
     #
-    #   class MyRenderer < Ruport::Renderer
+    #   class MyController < Ruport::Controller
     #      # other details omitted...
     #      finalize :apple
     #   end
     #
     #   class MyFormatter < Ruport::Formatter
-    #      renders :example, :for => MyRenderer
+    #      renders :example, :for => MyController
     # 
     #      # other details omitted... 
     #    
     #      def finalize_apple
-    #         # this method will be called when MyRenderer tries to render
+    #         # this method will be called when MyController tries to render
     #         # the :example format
     #      end
     #   end  
@@ -223,16 +320,16 @@ class Ruport::Renderer
     #
     # Usage:
     #
-    #   class MyRenderer < Ruport::Renderer
+    #   class MyController < Ruport::Controller
     #      # other details omitted...
     #      prepare :apple
     #   end
     #
     #   class MyFormatter < Ruport::Formatter
-    #      renders :example, :for => MyRenderer
+    #      renders :example, :for => MyController
     #
     #      def prepare_apple
-    #         # this method will be called when MyRenderer tries to render
+    #         # this method will be called when MyController tries to render
     #         # the :example format
     #      end        
     #      
@@ -252,21 +349,21 @@ class Ruport::Renderer
     #
     # Usage:
     #
-    #   class MyRenderer < Ruport::Renderer
+    #   class MyController < Ruport::Controller
     #      # other details omitted...
     #      stage :apple,:banana
     #   end
     #
     #   class MyFormatter < Ruport::Formatter
-    #      renders :example, :for => MyRenderer
+    #      renders :example, :for => MyController
     #
     #      def build_apple
-    #         # this method will be called when MyRenderer tries to render
+    #         # this method will be called when MyController tries to render
     #         # the :example format
     #      end 
     #   
     #      def build_banana
-    #         # this method will be called when MyRenderer tries to render
+    #         # this method will be called when MyController tries to render
     #         # the :example format
     #      end    
     #      
@@ -281,13 +378,13 @@ class Ruport::Renderer
       }
     end
      
-    # Defines attribute writers for the Renderer::Options object shared
-    # between Renderer and Formatter. Will throw an error if the user does
+    # Defines attribute writers for the Controller::Options object shared
+    # between Controller and Formatter. Will throw an error if the user does
     # not provide values for these options upon rendering.
     #
     # usage:
     #   
-    #   class MyRenderer < Ruport::Renderer
+    #   class MyController < Ruport::Controller
     #      required_option :employee_name, :address
     #      # other details omitted
     #   end
@@ -305,12 +402,12 @@ class Ruport::Renderer
       end
     end
 
-    # Lists the formatters that are currently registered on a renderer,
+    # Lists the formatters that are currently registered on a controller,
     # as a hash keyed by format name.
     #
     # Example:
     # 
-    #   >> Ruport::Renderer::Table.formats
+    #   >> Ruport::Controller::Table.formats
     #   => {:html=>Ruport::Formatter::HTML, 
     #   ?>  :csv=>Ruport::Formatter::CSV, 
     #   ?>  :text=>Ruport::Formatter::Text, 
@@ -319,20 +416,20 @@ class Ruport::Renderer
       @formats ||= {}
     end
     
-    # Builds up a renderer object, looks up the appropriate formatter,
+    # Builds up a controller object, looks up the appropriate formatter,
     # sets the data and options, and then does the following process:
     #
-    #   * If the renderer contains a module Helpers, mix it in to the instance.
-    #   * If a block is given, yield the Renderer instance.
-    #   * If a setup() method is defined on the Renderer, call it.
+    #   * If the controller contains a module Helpers, mix it in to the instance.
+    #   * If a block is given, yield the Controller instance.
+    #   * If a setup() method is defined on the Controller, call it.
     #   * Call the run() method.
     #   * If the :file option is set to a file name, appends output to the file.
     #   * Return the results of formatter.output
     #
-    # Please see the examples/ directory for custom renderer examples, because
+    # Please see the examples/ directory for custom controller examples, because
     # this is not nearly as complicated as it sounds in most cases.
-    def render(*args)
-      rend = build(*args) { |r|        
+    def render(format, add_options=nil)
+      rend = build(format, add_options) { |r|
           yield(r) if block_given?   
         r.setup if r.respond_to? :setup
       }  
@@ -348,7 +445,7 @@ class Ruport::Renderer
     #  options { |o| o.style = :justified }
     #
     def options
-      @options ||= Ruport::Renderer::Options.new
+      @options ||= Ruport::Controller::Options.new
       yield(@options) if block_given?
 
       return @options
@@ -356,37 +453,37 @@ class Ruport::Renderer
 
     private
     
-    # Creates a new instance of the renderer and sets it to use the specified
-    # formatter (by name).  If a block is given, the renderer instance is
+    # Creates a new instance of the controller and sets it to use the specified
+    # formatter (by name).  If a block is given, the controller instance is
     # yielded.  
     #
-    # Returns the renderer instance.
+    # Returns the controller instance.
     #
-    def build(*args)
+    def build(format, add_options=nil)
       rend = self.new
 
-      rend.send(:use_formatter,args[0])
+      rend.send(:use_formatter, format)
       rend.send(:options=, options.dup)
       if rend.class.const_defined? :Helpers
         rend.formatter.extend(rend.class.const_get(:Helpers))
       end
-      if args[1].kind_of?(Hash)
-        d = args[1].delete(:data)
+      if add_options.kind_of?(Hash)
+        d = add_options.delete(:data)
         rend.data = d if d
-        args[1].each {|k,v| rend.options.send("#{k}=",v) }
+        add_options.each {|k,v| rend.options.send("#{k}=",v) }
       end
 
       yield(rend) if block_given?
       return rend
     end
     
-    # Allows you to register a format with the renderer.
+    # Allows you to register a format with the controller.
     #
     # Example:
     #
     #   class MyFormatter < Ruport::Formatter
     #     # formatter code ...
-    #     SomeRenderer.add_format self, :my_formatter
+    #     SomeController.add_format self, :my_formatter
     #   end
     #
     def add_format(format,name=nil)
@@ -408,23 +505,23 @@ class Ruport::Renderer
 
   # Sets +data+ attribute on the active formatter.
   def data=(val)
-    formatter.data = val.dup 
+    formatter.data = val
   end
 
-  # Renderer::Options object which is shared with the current formatter.
+  # Controller::Options object which is shared with the current formatter.
   def options
     yield(formatter.options) if block_given?
     formatter.options
   end
   
   # Call the _run_ method.  You can override this method in your custom
-  # renderer if you need to define other actions.
+  # controller if you need to define other actions.
   def run
     _run_
   end
   
   # If an IO object is given, Formatter#output will use it instead of 
-  # the default String.  For Ruport's core renderers, we technically
+  # the default String.  For Ruport's core controllers, we technically
   # can use any object that supports the << method, but it's meant
   # for IO objects such as File or STDOUT
   #
@@ -456,7 +553,6 @@ class Ruport::Renderer
   # Called automatically when the report is rendered. Uses the
   # data collected from the earlier methods.
   def _run_
-    # ensure all the required options have been set
     unless self.class.required_options.nil?
       self.class.required_options.each do |opt|
         if options.__send__(opt).nil?
@@ -479,10 +575,10 @@ class Ruport::Renderer
     end
 
     finalize self.class.final_stage if self.class.final_stage
+    maybe :finalize
   end  
   
   def execute_stages
-    # call each stage to build the report
     unless self.class.stages.nil?
       self.class.stages.each do |stage|
         maybe("build_#{stage}")
@@ -516,5 +612,5 @@ class Ruport::Renderer
 
 end
 
-require "ruport/renderer/table"
-require "ruport/renderer/grouping"         
+require "ruport/controller/table"
+require "ruport/controller/grouping"