jsanders-ruport 1.7.1

data/lib/ruport/formatter/template.rb

@@ -0,0 +1,187 @@
+# Ruport : Extensible Reporting System                                
+#
+# template.rb provides templating support for Ruby Reports.
+#
+# Copyright August 2007, Gregory Brown / Michael Milner.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+
+class Ruport::Formatter::TemplateNotDefined < StandardError; end       
+
+# This class provides templating functionality for Ruport.
+# New templates are created using the Template.create method.
+#
+# Example:
+#
+#   Ruport::Formatter::Template.create(:simple) do |t|
+#     t.page_layout = :landscape
+#     t.grouping_style = :offset
+#   end
+#
+# You can then determine how the template should be used by defining
+# an <tt>apply_template</tt> method in your formatter.
+#
+# Example:
+#
+#   class Ruport::Formatter::PDF 
+#     def apply_template
+#       options.paper_orientation = template.page_layout
+#       options.style = template.grouping_style
+#     end
+#   end
+#
+# When you're ready to render the output, you can set the :template as an
+# option for the formatter. Using the template remains optional and you can
+# still render the report without it.
+#
+# Example:
+#
+#   puts g.to_pdf(:template => :simple) #=> uses the template
+#   puts g.to_pdf                       #=> doesn't use the template
+#
+# The built-in formatters all have <tt>apply_template</tt> methods defined that
+# accept a standard set of options. Each option can be set by supplying a hash
+# with the keys/values listed in the tables below.
+#
+# Example:
+#
+#   Ruport::Formatter::Template.create(:simple) do |format|
+#     format.page = {
+#       :size   => "LETTER",
+#       :layout => :landscape
+#     }
+#   end
+#
+# If you define a template with the name :default, then it will be used by
+# all formatters unless they either specify a template or explicitly turn off
+# the templating functionality by using :template => false.
+#
+# Example:
+#
+#   Ruport::Formatter::Template.create(:simple)
+#   Ruport::Formatter::Template.create(:default)
+#
+#   puts g.to_pdf                       #=> uses the :default template
+#   puts g.to_pdf(:template => :simple) #=> uses the :simple template
+#   puts g.to_pdf(:template => false)   #=> doesn't use a template
+#
+# ==== PDF Formatter Options
+#
+#   Option          Key                 Value
+# 
+#   page            :size               Any size supported by the :paper
+#                                       option to PDF::Writer.new
+# 
+#                   :layout             :portrait, :landscape
+# 
+#   text            Any available to    Corresponding values
+#                   PDF::Writer#text
+# 
+#   table           All attributes of   Corresponding values
+#                   PDF::SimpleTable
+# 
+#                   :column_options     - All attributes of
+#                                         PDF::SimpleTable::Column
+#                                         except :heading
+#                                       - Hash keyed by a column name, whose
+#                                         value is a hash containing any of
+#                                         the other:column_options (sets values
+#                                         for specific columns)
+#                                       - :heading => { All attributes of
+#                                         PDF::SimpleTable::Column::Heading }
+# 
+#   column          :alignment          :left, :right, :center, :full
+# 
+#                   :width              column width
+# 
+#   heading         :alignment          :left, :right, :center, :full
+# 
+#                   :bold               true or false
+# 
+#                   :title              heading title (if not set,
+#                                       defaults to column name)
+# 
+#   grouping        :style              :inline, :justified, :separated, :offset
+#
+#
+# ==== Text Formatter Options
+# 
+#   Option          Key                 Value
+# 
+#   table           :show_headings      true or false
+#                   :width              Table width
+#                   :ignore_width       true or false
+# 
+#   column          :alignment          :center
+#                   :maximum_width      Max column width
+# 
+#   grouping        :show_headings      true or false
+#
+#
+# ==== HTML Formatter Options
+# 
+#   Option          Key                 Value
+# 
+#   table           :show_headings      true or false
+# 
+#   grouping        :style              :inline, :justified
+#                   :show_headings      true or false
+#
+#
+# ==== CSV Formatter Options
+# 
+#   Option          Key                 Value
+# 
+#   table           :show_headings      true or false
+# 
+#   grouping        :style              :inline, :justified, :raw
+#                   :show_headings      true or false
+# 
+#   format_options  All options         Corresponding values
+#                   available to
+#                   FasterCSV.new
+#
+class Ruport::Formatter::Template < Ruport::Controller::Options
+  
+  # Returns all existing templates in a hash keyed by the template names.
+  def self.templates
+    @templates ||= Hash.new 
+  end
+  
+  # Creates a new template with a name given by <tt>label</tt>.
+  #
+  # Example:
+  #
+  #   Ruport::Formatter::Template.create(:simple) do |t|
+  #     t.page_layout = :landscape
+  #     t.grouping_style = :offset
+  #   end
+  #
+  # You can inherit all the options set in a template by using the :base option
+  # and providing an existing template name to use as the base.
+  #
+  # Example:
+  #
+  #   Ruport::Formatter::Template.create(:derived, :base => :simple)
+  #
+  def self.create(label,opts={})
+    if opts[:base]
+      obj = Marshal.load(Marshal.dump(self[opts[:base]]))
+    else
+      obj = new
+    end
+    yield(obj) if block_given?
+    templates[label] = obj
+  end
+  
+  # Returns an existing template with the provided name (label).
+  def self.[](label) 
+    templates[label] or raise Ruport::Formatter::TemplateNotDefined
+  end
+  
+  # Returns the default template.
+  def self.default
+    templates[:default]
+  end
+end   

data/lib/ruport/formatter/text.rb

@@ -0,0 +1,231 @@
+# Ruport : Extensible Reporting System                                
+#
+# formatter/text.rb provides text formatting for Ruport.
+#     
+# Created by Gregory Brown, some time around Spring 2006.
+# Copyright (C) 2006-2007, All Rights Reserved.  
+#
+# Mathijs Mohlmann and Marshall T. Vandegrift have provided some patches for
+# this class, see AUTHORS file for details.
+#
+# This is free software distributed under the same terms as Ruby 1.8
+# See LICENSE and COPYING for details.
+module Ruport
+  
+  # This class provides text output for Ruport's Row, Table, Group, and
+  # 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
+  # output that looks something like this:
+  #
+  #   +------------------------------+
+  #   | apple | banana | strawberry  |
+  #   +------------------------------+
+  #   | yes   | no     | yes         |
+  #   | yes   | yes    | red snapper |
+  #   | what  | the    | red snapper |
+  #   +------------------------------+ 
+  #
+  # === Supported Options 
+  #
+  # <tt>:max_col_width:</tt> Ordinal array of column widths.  Set automatically
+  # but can be overridden.
+  #
+  # <tt>:alignment:</tt> Defaults to left justify text and right justify
+  # numbers. Centers all fields when set to :center.
+  #
+  # <tt>:table_width:</tt> Will truncate rows at this limit.
+  #
+  # <tt>:show_table_headers:</tt> Defaults to true
+  #
+  # <tt>:show_group_headers:</tt> Defaults to true  
+  #
+  # <tt>:ignore_table_width:</tt> When set to true, outputs full table without
+  # truncating it.  Useful for file output.
+  class Formatter::Text < Formatter
+   
+    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.
+    def apply_template
+      apply_table_format_template(template.table)
+      apply_column_format_template(template.column)
+      apply_grouping_format_template(template.grouping)
+    end
+
+    # Checks to ensure the table is not empty and then calls
+    # calculate_max_col_widths.
+    #
+    def prepare_table
+      raise Ruport::FormatterError, "Can't output table without " +
+        "data or column names." if data.empty? && data.column_names.empty?
+      calculate_max_col_widths
+    end
+
+    # Uses the column names from the given Data::Table to generate a table
+    # header.
+    #
+    # Calls fit_to_width to truncate the table heading if necessary.
+    #
+    def build_table_header
+      return unless should_render_column_names?
+
+      c = data.column_names.enum_for(:each_with_index).map { |f,i|
+        f.to_s.center(options.max_col_width[i])
+      }
+
+      output << fit_to_width("#{hr}| #{c.join(' | ')} |\n")
+    end
+
+    # Generates the body of the text table. 
+    #
+    # Defaults to numeric values being right justified, and other values being
+    # left justified.  Can be changed to support centering of output by
+    # setting options.alignment to :center
+    #
+    # Uses fit_to_width to truncate the table if necessary.
+    #
+    def build_table_body
+      output << fit_to_width(hr)
+      return if data.empty?
+
+      calculate_max_col_widths unless options.max_col_width
+
+      data.each { |row| build_row(row) }
+
+      output << fit_to_width(hr)
+    end
+    
+    # Generates a formatted text row. 
+    #
+    # Defaults to numeric values being right justified, and other values being
+    # left justified.  Can be changed to support centering of output by
+    # setting options.alignment to :center
+    #
+    # Uses fit_to_width to truncate the row if necessary.
+    #
+    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|
+        field,index = e
+        if options.alignment.eql? :center
+          line << field.to_s.center(options.max_col_width[index])
+        else
+          align = field.is_a?(Numeric) ? :rjust : :ljust
+          line << field.to_s.send(align, options.max_col_width[index])
+        end
+      }
+      output << fit_to_width("| #{line.join(' | ')} |\n")
+    end
+
+    # Renders the header for a group using the group name.
+    #
+    def build_group_header
+      output << "#{data.name}:\n\n"
+    end
+    
+    # Creates the group body. Since group data is a table, just uses the
+    # 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 controller.
+    #
+    def build_grouping_body
+      render_inline_grouping(options)
+    end
+    
+    # Returns false if column_names are empty or options.show_table_headers
+    # is false/nil.  Returns true otherwise.
+    #
+    def should_render_column_names?
+      not data.column_names.empty? || !options.show_table_headers
+    end
+
+    # Generates the horizontal rule by calculating the total table width and
+    # then generating a bar that looks like this:
+    #
+    #   "+------------------+"
+    def hr
+      ref = data.column_names.empty? ? data[0].to_a : data.column_names
+      len = options.max_col_width.inject(ref.length * 3) {|s,e|s+e}
+      "+" + "-"*(len-1) + "+\n"
+    end
+    
+    # Returns options.table_width if specified.
+    #
+    # Otherwise, uses SystemExtensions to determine terminal width.
+    def width
+      options.table_width ||= SystemExtensions.terminal_width
+    end
+
+    # Truncates a string so that it does not exceed Text#width
+    def fit_to_width(s)      
+      return s if options.ignore_table_width
+      # workaround for Rails setting terminal_width to 1
+      max_width = width < 2 ? 80 : width
+      
+      s.split("\n").each { |r|
+         r.gsub!(/\A.{#{max_width+1},}/) { |m| m[0,max_width-2] + ">>" }
+      }.join("\n") + "\n"
+    end
+
+    # Determines the text widths for each column.
+    def calculate_max_col_widths
+      # allow override
+      return if options.max_col_width
+
+      options.max_col_width = []
+
+      unless data.column_names.empty?
+        data.column_names.each_index do |i| 
+          options.max_col_width[i] = data.column_names[i].to_s.length
+        end
+      end
+          
+      data.each { |r| max_col_widths_for_row(r) } 
+    end
+    
+    # Used to calculate the <tt>max_col_widths</tt> array.
+    # Override this to tweak the automatic column size adjustments.
+    def max_col_widths_for_row(row)
+      options.max_col_width ||= []
+      row.each_with_index do |f,i|
+        if !options.max_col_width[i] || f.to_s.length > options.max_col_width[i]
+          options.max_col_width[i] = f.to_s.length
+        end
+      end
+    end
+    
+    private
+    
+    def apply_table_format_template(t)
+      t = (t || {}).merge(options.table_format || {})
+      options.show_table_headers = t[:show_headings] if
+        options.show_table_headers.nil?
+      options.table_width ||= t[:width]
+      options.ignore_table_width = t[:ignore_width] if
+        options.ignore_table_width.nil?
+    end
+    
+    def apply_column_format_template(t)
+      t = (t || {}).merge(options.column_format || {})
+      options.max_col_width ||= t[:maximum_width]
+      options.alignment ||= t[:alignment]
+    end
+    
+    def apply_grouping_format_template(t)
+      t = (t || {}).merge(options.grouping_format || {})
+      options.show_group_headers = t[:show_headings] if
+        options.show_group_headers.nil?
+    end
+
+  end
+end

data/lib/uport.rb

@@ -0,0 +1 @@
+require "ruport"

data/test/controller_test.rb

@@ -0,0 +1,743 @@
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
+
+###########################################################################
+#
+#  NOTE:
+#
+#  As it stands, we haven't found a more clever way to test the formatting
+#  system than to just create a bunch of renderers and basic formatters for
+#  different concepts we're trying to test.  Patches and ideas welcome:
+#
+#  list.rubyreports.org
+############################################################################
+
+#============================================================================
+# These two renderers represent the two styles that can be used when defining
+# renderers in Ruport.  The OldSchoolController approach has largely been
+# deprecated, but still has uses in edge cases that we need to support.
+#============================================================================
+
+class OldSchoolController < Ruport::Controller
+
+  def run
+    formatter do
+      build_header
+      build_body
+      build_footer
+    end
+  end
+
+end               
+
+class VanillaController < Ruport::Controller
+  stage :header,:body,:footer
+end
+
+
+# This formatter implements some junk output so we can be sure
+# that the hooks are being set up right.  Perhaps these could
+# be replaced by mock objects in the future.
+class DummyText < Ruport::Formatter
+  
+  renders :text, :for => OldSchoolController
+  
+  def prepare_document
+    output << "p"
+  end
+
+  def build_header
+    output << "header\n"
+  end
+
+  def build_body
+    output << "body\n"
+  end
+
+  def build_footer
+    output << "footer\n"
+  end
+
+  def finalize_document
+    output << "f"
+  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 => VanillaController
+  save_as_binary_file
+end 
+
+class SpecialFinalize < Ruport::Formatter
+  renders :with_finalize, :for => VanillaController
+  
+  def finalize
+    output << "I has been finalized"
+  end
+end
+
+class TestController < Test::Unit::TestCase
+
+  def teardown
+    Ruport::Formatter::Template.instance_variable_set(:@templates, nil)
+  end
+
+  def test_trivial
+    actual = OldSchoolController.render(:text)
+    assert_equal "header\nbody\nfooter\n", actual
+  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
+      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
+    require "stringio"
+    out = StringIO.new
+    a = OldSchoolController.render(:text) { |r| r.io = out }
+    out.rewind
+    assert_equal "header\nbody\nfooter\n", out.read
+    assert_equal "", out.read
+  end
+
+  def test_using_file
+    f = []
+    File.expects(:open).yields(f)
+    a = OldSchoolController.render(:text, :file => "foo.text")
+    assert_equal "header\nbody\nfooter\n", f[0]
+    
+    f = []
+    File.expects(:open).with("blah","wb").yields(f)
+    VanillaController.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::Controller.formats )
+    assert_equal( { :text => DummyText },OldSchoolController.formats )
+  end
+
+  def test_method_missing
+    actual = OldSchoolController.render_text
+    assert_equal "header\nbody\nfooter\n", actual
+  end
+
+  def test_formatter
+    # normal instance mode
+    rend = OldSchoolController.new
+    rend.send(:use_formatter,:text)
+
+    assert_kind_of Ruport::Formatter, rend.formatter
+    assert_kind_of DummyText, rend.formatter
+
+    # render mode
+    OldSchoolController.render_text do |r|
+      assert_kind_of Ruport::Formatter, r.formatter
+      assert_kind_of DummyText, r.formatter
+    end
+
+    assert_equal "body\n", rend.formatter { build_body }.output
+
+    rend.formatter.clear_output
+    assert_equal "", rend.formatter.output
+  end  
+  
+  def test_options_act_like_indifferent_hash
+     opts = Ruport::Controller::Options.new
+     opts.foo = "bar"
+     assert_equal "bar", opts[:foo]
+     assert_equal "bar", opts["foo"]    
+     
+     opts["f"] = "bar"
+     assert_equal "bar", opts[:f]
+     assert_equal "bar", opts.f
+     assert_equal "bar", opts["f"]
+     
+     opts[:apple] = "banana"
+     assert_equal "banana", opts.apple
+     assert_equal "banana", opts["apple"]
+     assert_equal "banana", opts[:apple]
+  end     
+  
+end
+
+
+class TestFormatterUsingBuild < Test::Unit::TestCase
+  # This formatter uses the build syntax
+  class UsesBuild < Ruport::Formatter
+     renders :text_using_build, :for => VanillaController 
+     
+     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",
+      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)
+    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
+  class WithLayout < DummyText
+     renders :text_with_layout, :for => VanillaController 
+     
+     def layout     
+       output << "---\n"
+       yield
+       output << "---\n"
+     end
+     
+  end
+
+  def test_layout
+     assert_equal "---\nheader\nbody\nfooter\n---\n", 
+                  VanillaController.render_text_with_layout
+  end
+  
+  def test_layout_disabled
+     assert_equal "header\nbody\nfooter\n",
+                  VanillaController.render_text_with_layout(:layout => false)
+  end
+
+end
+
+
+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
+
+    stage :header
+    stage :body
+    stage :footer
+
+    finalize :document
+
+    def setup
+      options.apple = true
+    end
+
+  end
+
+  def test_hash_options_setters
+    a = ControllerWithManyHooks.render(:text, :subtitle => "foo",
+                                       :subsubtitle => "bar") { |r|
+      assert_equal "foo", r.options.subtitle
+      assert_equal "bar", r.options.subsubtitle
+    }
+  end
+
+  def test_data_accessors
+   a = ControllerWithManyHooks.render(:text, :data => [1,2,4]) { |r|
+     assert_equal [1,2,4], r.data
+   }
+  
+   b = ControllerWithManyHooks.render_text(%w[a b c]) { |r|
+     assert_equal %w[a b c], r.data
+   }
+  
+   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 ControllerWithManyHooks.stages.include?('body')
+  end
+ 
+  def test_finalize_helper
+    assert_equal :document, ControllerWithManyHooks.final_stage
+  end
+
+  def test_prepare_helper
+   assert_equal :document, ControllerWithManyHooks.first_stage
+  end
+
+  def test_finalize_again
+   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+     ControllerWithManyHooks.finalize :report 
+   }
+  end
+
+  def test_prepare_again
+   assert_raise(Ruport::Controller::StageAlreadyDefinedError) { 
+     ControllerWithManyHooks.prepare :foo 
+   }
+  end
+
+  def test_renderer_using_helpers
+   actual = ControllerWithManyHooks.render(:text)
+   assert_equal "pheader\nbody\nfooter\nf", actual
+
+   actual = ControllerWithManyHooks.render_text
+   assert_equal "pheader\nbody\nfooter\nf", actual
+  end
+
+  def test_required_option_helper
+   a = ControllerWithManyHooks.dup
+   a.required_option :title
+
+   a.render_text do |r|
+     r.title = "Test Report"
+     assert_equal "Test Report", r.options.title
+   end
+
+  end
+
+  def test_without_required_option
+   a = ControllerWithManyHooks.dup
+   a.required_option :title
+
+   assert_raise(Ruport::Controller::RequiredOptionNotSet) { a.render(:text) }
+  end
+ 
+end
+
+
+class TestControllerWithRunHook < Test::Unit::TestCase
+
+  class ControllerWithRunHook < Ruport::Controller
+    add_format DummyText, :text
+
+    required_option :foo,:bar
+    stage :header
+    stage :body
+    stage :footer
+
+    def run
+      formatter.output << "|"
+      super
+    end
+
+  end
+
+  def test_renderer_with_run_hooks
+    assert_equal "|header\nbody\nfooter\n", 
+       ControllerWithRunHook.render_text(:foo => "bar",:bar => "baz")
+  end
+
+end
+
+
+class TestControllerWithHelperModule < Test::Unit::TestCase
+
+  class ControllerWithHelperModule < VanillaController
+
+    add_format DummyText, :stub
+
+    module Helpers
+      def say_hello
+        "Hello Dolly"
+      end
+    end
+  end   
+
+  def test_renderer_helper_module
+    ControllerWithHelperModule.render_stub do |r|
+      assert_equal "Hello Dolly", r.formatter.say_hello
+    end
+  end
+end
+
+
+class TestMultiPurposeFormatter < Test::Unit::TestCase
+  # This provides a way to check the multi-format hooks for the Controller
+  class MultiPurposeFormatter < Ruport::Formatter 
+
+     renders [:html,:text], :for => VanillaController
+
+     def build_header
+       a = 10
+
+       text { output << "Foo: #{a}\n" }
+       html { output << "<b>Foo: #{a}</b>\n" } 
+     end
+
+     def build_body
+       html { output << "<pre>\n" }
+       output << options.body_text
+       html { output << "\n</pre>\n" }
+     end
+
+  end   
+
+  def test_multi_purpose
+    text = VanillaController.render_text(:body_text => "foo")
+    assert_equal "Foo: 10\nfoo", text
+    html = VanillaController.render_html(:body_text => "bar")
+    assert_equal "<b>Foo: 10</b>\n<pre>\nbar\n</pre>\n",html
+  end
+
+
+  def test_method_missing_hack_formatter
+    assert_equal [:html,:text], MultiPurposeFormatter.formats
+
+    a = MultiPurposeFormatter.new
+    a.format = :html
+    
+    visited = false
+    a.html { visited = true }
+
+    assert visited
+    
+    visited = false
+    a.text { visited = true }
+    assert !visited
+
+    assert_raises(NoMethodError) do
+      a.pdf { 'do nothing' }
+    end
+  end
+
+end
+
+
+class TestFormatterErbHelper < Test::Unit::TestCase
+  class ErbFormatter < Ruport::Formatter
+     
+    renders :terb, :for  => VanillaController
+    
+    def build_body    
+       # demonstrate local binding
+       @foo = "bar"                         
+       if options.binding
+         output << erb("Binding Override: <%= reverse %>", 
+                       :binding => options.binding) 
+       else   
+         output << erb("Default Binding: <%= @foo %>") 
+       end   
+    end
+    
+  end
+
+   #FIXME: need to test file
+
+   def test_self_bound
+     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", 
+                   VanillaController.render_terb(:binding => arr_binding)
+   end
+end    
+
+
+class TestOptionReaders < Test::Unit::TestCase
+  
+  class ControllerForCheckingOptionReaders < Ruport::Controller
+    required_option :foo  
+  end 
+  
+  class ControllerForCheckingPassivity < Ruport::Controller
+    def foo
+      "apples"
+    end
+    required_option :foo    
+  end
+
+   def setup 
+     @renderer = ControllerForCheckingOptionReaders.new 
+     @renderer.formatter = Ruport::Formatter.new 
+     
+     @passive = ControllerForCheckingPassivity.new
+     @passive.formatter = Ruport::Formatter.new
+   end
+   
+   def test_options_are_readable
+      @renderer.foo = 5
+      assert_equal 5, @renderer.foo
+   end                                   
+   
+   def test_methods_are_not_overridden
+     @passive.foo = 5
+     assert_equal "apples", @passive.foo
+     assert_equal 5, @passive.options.foo
+     assert_equal 5, @passive.formatter.options.foo
+   end
+     
+end
+     
+class TestSetupOrdering < Test::Unit::TestCase
+   
+  class ControllerWithSetup < Ruport::Controller
+    stage :bar
+    def setup
+      options.foo.capitalize!
+    end        
+  end           
+  
+  class BasicFormatter < Ruport::Formatter 
+    renders :text, :for => ControllerWithSetup
+    
+    def build_bar
+      output << options.foo
+    end
+  end
+  
+  def test_render_hash_options_should_be_called_before_setup
+    assert_equal "Hello", ControllerWithSetup.render_text(:foo => "hello")
+  end       
+  
+  def test_render_block_should_be_called_before_setup
+    assert_equal "Hello", 
+      ControllerWithSetup.render_text { |r| r.options.foo = "hello" }
+  end
+  
+end
+
+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::Controller::Hooks
+      renders_as_table
+    end
+
+    def specify_should_return_self
+      a = DummyObject.new
+      rend = mock("renderer")
+      rend.expects(:data=).with(a)
+      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
+
+  end
+
+  context "when using renderable_data" do
+
+    class DummyObject2
+      include Ruport::Controller::Hooks
+      renders_as_table
+
+      def renderable_data(format)
+        1
+      end
+    end
+
+    def specify_should_return_results_of_renderable_data
+      a = DummyObject2.new
+      rend = mock("renderer")
+      rend.expects(:data=).with(1)
+      Ruport::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
+
+    class DummyObject3
+      include Ruport::Controller::Hooks
+      renders_as_table
+      
+      def renderable_data
+        raise ArgumentError
+      end
+    end
+
+    def specify_should_not_mask_errors
+      assert_raises(ArgumentError) { DummyObject3.new.as(:csv) }
+    end
+
+    class DummyObject4
+      include Ruport::Controller::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::Controller::Table.expects(:render).with(:csv,{}).yields(rend)
+      a.as(:csv)
+    end
+
+  end    
+
+  context "when attempting to render a format that doesn't exist" do
+
+    def specify_an_unknown_format_error_should_be_raised
+
+      assert_raises(Ruport::Controller::UnknownFormatError) do
+        Ruport::Controller.render_foo
+      end
+
+    end
+  end
+
+
+
+end