Parent

Files

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

Public Class Methods

build(stage,&block) click to toggle source

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
# File lib/ruport/formatter.rb, line 171
def self.build(stage,&block)
  define_method "build_#{stage}", &block
end
formats() click to toggle source

Gives a list of formats registered for this formatter.

# File lib/ruport/formatter.rb, line 176
def self.formats
  @formats ||= []
end
renders(fmts,options={}) click to toggle source

Registers the formatter with one or more Controllers.

renders :pdf, :for => MyController
render :text, :for => [MyController,YourController]
renders [:csv,:html], :for => YourController
# File lib/ruport/formatter.rb, line 146
def self.renders(fmts,options={})
  Array(fmts).each do |format|
    Array(options[:for]).each do |o| 
      o.send(:add_format,self,format) 
      formats << format unless formats.include?(format)
    end    
  end
end
save_as_binary_file() click to toggle source

Use to define that your formatter should save in binary format

# File lib/ruport/formatter.rb, line 214
def self.save_as_binary_file
  define_method :save_output do |filename|
    File.open(filename,"wb") {|f| f << output }
  end
end

Public Instance Methods

clear_output() click to toggle source

Clears the output.

# File lib/ruport/formatter.rb, line 204
def clear_output
  @output.replace("")
end
data=(val) click to toggle source

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.

# File lib/ruport/formatter.rb, line 199
def data=(val)
  @data = val.dup
end
erb(string,options={}) click to toggle source

Evaluates the string using ERB and returns the results.

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

# File lib/ruport/formatter.rb, line 224
def erb(string,options={})      
  require "erb"
  if string =~ /(\.r\w+)|(\.erb)$/
    ERB.new(File.read(string)).result(options[:binding]||binding)
  else
    ERB.new(string).result(options[:binding]||binding)
  end
end
method_missing(id,*args) click to toggle source

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" }
# File lib/ruport/formatter.rb, line 240
def method_missing(id,*args)
  if self.class.formats.include?(id)
    yield() if format == id
  else
    super
  end
end
options() click to toggle source

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

# File lib/ruport/formatter.rb, line 192
def options
  @options ||= Controller::Options.new
end
output() click to toggle source

Stores a string used for outputting formatted data.

# File lib/ruport/formatter.rb, line 186
def output
  return options.io if options.io
  @output ||= ""
end
save_output(filename) click to toggle source

Saves the output to a file.

# File lib/ruport/formatter.rb, line 209
def save_output(filename)
  File.open(filename,"w") {|f| f << output }
end
template() click to toggle source

Returns the template currently set for this formatter.

# File lib/ruport/formatter.rb, line 181
def template
  Template[options.template] rescue nil || Template[:default]
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.