Class: Ruport::Formatter

Formatter is the base class for Ruport’s format implementations.

Typically, a Formatter will implement one or more output types, and be registered with one or more Controller classes.

This class provides all the necessary base functionality to make use of Ruport’s rendering system, including option handling, data access, and basic output wrapping.

The following example should provide a general idea of how formatters work, but see the built in formatters for reference implementations.

A simple Controller definition is included to help show the example in context, but you can also build your own custom interface to formatter if you wish.

  class ReverseController < Ruport::Controller
     stage :reversed_header, :reversed_body
  end

  class ReversedText < Ruport::Formatter

     # Hooks formatter up to controller
     renders :txt, :for => ReverseController

     # Implements ReverseController's :reversed_header hook
     # but can be used by any controller
     def build_reversed_header
        output << "#{options.header_text}\n"
        output << "The reversed text will follow\n"
     end

     # Implements ReverseController's :reversed_body hook
     # but can be used by any controller
     def build_reversed_body
        output << data.reverse << "\n"
     end

  end

  puts ReverseController.render_txt(:data => "apple",
                                  :header_text => "Hello Mike, Hello Joe!")

  -----
  OUTPUT:

  Hello Mike, Hello Joe!
  The reversed text will follow
  elppa

Methods

build clear_output data= erb formats method_missing options output renders save_as_binary_file save_output template

Classes and Modules

Module Ruport::Formatter::RenderingTools

Attributes

data	[R]	Set by the `:data` attribute from Controller#render
format	[RW]	Set automatically by Controller#render(format) or Controller#render_format
options	[W]	Set automatically by Controller#render as a Controller::Options object built by the hash provided.

Public Class methods

build(stage,&block)

Allows you to implement stages in your formatter using the following syntax:

  class ReversedText < Ruport::Formatter
     renders :txt, :for => ReverseController

     build :reversed_header do
        output << "#{options.header_text}\n"
        output << "The reversed text will follow\n"
     end

     build :reversed_body do
        output << data.reverse << "\n"
     end
  end

formats()

Gives a list of formats registered for this formatter.

renders(fmts,options={})

Registers the formatter with one or more Controllers.

  renders :pdf, :for => MyController
  render :text, :for => [MyController,YourController]
  renders [:csv,:html], :for => YourController

save_as_binary_file()

Use to define that your formatter should save in binary format

Public Instance methods

clear_output()

Clears the output.

data=(val)

Sets the data object, making a local copy using dup. This may have a significant overhead for large tables, so formatters which don’t modify the data object may wish to override this.

erb(string,options={})

Evaluates the string using ERB and returns the results.

If :binding is specified, it will evaluate the template in that context.

method_missing(id,*args) {|| ...}

Provides a shortcut for per-format handlers.

Example:

  # will only be called if formatter is called for html output
  html { output << "Look, I'm handling html" }

options()

Provides a Controller::Options object for storing formatting options.

output()

Stores a string used for outputting formatted data.

save_output(filename)

Saves the output to a file.

template()

Returns the template currently set for this formatter.

Methods

Included Modules

Classes and Modules

Attributes

Public Class methods

Public Instance methods