ruport 1.2.3 → 1.4.0

data/lib/ruport/formatter/template.rb

@@ -46,26 +46,39 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 #
 # Example:
 #
-#   Ruport::Formatter::Template.create(:simple) do |t|
-#     t.page_format = {
+#   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_format     :size               Any size supported by the :paper
+#   page            :size               Any size supported by the :paper
 #                                       option to PDF::Writer.new
 # 
 #                   :layout             :portrait, :landscape
 # 
-#   text_format     Any available to    Corresponding values
+#   text            Any available to    Corresponding values
 #                   PDF::Writer#text
 # 
-#   table_format    All attributes of   Corresponding values
+#   table           All attributes of   Corresponding values
 #                   PDF::SimpleTable
 # 
 #                   :column_options     - All attributes of
@@ -78,41 +91,41 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 #                                       - :heading => { All attributes of
 #                                         PDF::SimpleTable::Column::Heading }
 # 
-#   column_format   :alignment          :left, :right, :center, :full
+#   column          :alignment          :left, :right, :center, :full
 # 
 #                   :width              column width
 # 
-#   heading_format  :alignment          :left, :right, :center, :full
+#   heading         :alignment          :left, :right, :center, :full
 # 
 #                   :bold               true or false
 # 
 #                   :title              heading title (if not set,
 #                                       defaults to column name)
 # 
-#   grouping_format :style              :inline, :justified, :separated, :offset
+#   grouping        :style              :inline, :justified, :separated, :offset
 #
 #
 # ==== Text Formatter Options
 # 
 #   Option          Key                 Value
 # 
-#   table_format    :show_headings      true or false
+#   table           :show_headings      true or false
 #                   :width              Table width
 #                   :ignore_width       true or false
 # 
-#   column_format   :alignment          :center
+#   column          :alignment          :center
 #                   :maximum_width      Max column width
 # 
-#   grouping_format :show_headings      true or false
+#   grouping        :show_headings      true or false
 #
 #
 # ==== HTML Formatter Options
 # 
 #   Option          Key                 Value
 # 
-#   table_format    :show_headings      true or false
+#   table           :show_headings      true or false
 # 
-#   grouping_format :style              :inline, :justified
+#   grouping        :style              :inline, :justified
 #                   :show_headings      true or false
 #
 #
@@ -120,9 +133,9 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 # 
 #   Option          Key                 Value
 # 
-#   table_format    :show_headings      true or false
+#   table           :show_headings      true or false
 # 
-#   grouping_format :style              :inline, :justified, :raw
+#   grouping        :style              :inline, :justified, :raw
 #                   :show_headings      true or false
 # 
 #   format_options  All options         Corresponding values
@@ -166,4 +179,9 @@ class Ruport::Formatter::Template < Ruport::Renderer::Options
   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

@@ -45,19 +45,15 @@ module Ruport
   # truncating it.  Useful for file output.
   class Formatter::Text < Formatter
    
-    renders :text, :for => [ Renderer::Row, Renderer::Table,
-                             Renderer::Group, Renderer::Grouping ]
+    renders [:txt, :text], :for => [ Renderer::Row, Renderer::Table,
+                                     Renderer::Group, Renderer::Grouping ]
 
-    opt_reader :max_col_width, :alignment, :table_width, 
-               :show_table_headers, :show_group_headers,
-               :ignore_table_width
-    
     # 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_format)
-      apply_column_format_template(template.column_format)
-      apply_grouping_format_template(template.grouping_format)
+      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
@@ -78,7 +74,7 @@ module Ruport
       return unless should_render_column_names?
 
       c = data.column_names.enum_for(:each_with_index).map { |f,i|
-        f.to_s.center(max_col_width[i])
+        f.to_s.center(options.max_col_width[i])
       }
 
       output << fit_to_width("#{hr}| #{c.join(' | ')} |\n")
@@ -96,14 +92,14 @@ module Ruport
       output << fit_to_width(hr)
       return if data.empty?
 
-      calculate_max_col_widths unless max_col_width
+      calculate_max_col_widths unless options.max_col_width
 
       render_data_by_row do |rend|
         rend.options do |o|
-          o.max_col_width = max_col_width
-          o.alignment     = alignment
-          o.table_width   = table_width   
-          o.ignore_table_width = ignore_table_width
+          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
 
@@ -119,15 +115,15 @@ module Ruport
     # Uses fit_to_width to truncate the row if necessary.
     #
     def build_row
-      max_col_widths_for_row(data) unless max_col_width
+      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 alignment.eql? :center
-          line << field.to_s.center(max_col_width[index])
+        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, max_col_width[index])
+          line << field.to_s.send(align, options.max_col_width[index])
         end
       }
       output << fit_to_width("| #{line.join(' | ')} |\n")
@@ -157,7 +153,7 @@ module Ruport
     # is false/nil.  Returns true otherwise.
     #
     def should_render_column_names?
-      not data.column_names.empty? || !show_table_headers
+      not data.column_names.empty? || !options.show_table_headers
     end
 
     # Generates the horizontal rule by calculating the total table width and
@@ -166,7 +162,7 @@ module Ruport
     #   "+------------------+"
     def hr
       ref = data.column_names.empty? ? data[0].to_a : data.column_names
-      len = max_col_width.inject(ref.length * 3) {|s,e|s+e}
+      len = options.max_col_width.inject(ref.length * 3) {|s,e|s+e}
       "+" + "-"*(len-1) + "+\n"
     end
     
@@ -174,7 +170,7 @@ module Ruport
     #
     # Otherwise, uses SystemExtensions to determine terminal width.
     def width
-      table_width || SystemExtensions.terminal_width
+      options.table_width || SystemExtensions.terminal_width
     end
 
     # Truncates a string so that it does not exceed Text#width
@@ -191,13 +187,13 @@ module Ruport
     # Determines the text widths for each column.
     def calculate_max_col_widths
       # allow override
-      return if max_col_width
+      return if options.max_col_width
 
       options.max_col_width = []
 
       unless data.column_names.empty?
         data.column_names.each_index do |i| 
-          max_col_width[i] = data.column_names[i].to_s.length
+          options.max_col_width[i] = data.column_names[i].to_s.length
         end
       end
           
@@ -209,8 +205,8 @@ module Ruport
     def max_col_widths_for_row(row)
       options.max_col_width ||= []
       row.each_with_index do |f,i|
-        if !max_col_width[i] || f.to_s.length > max_col_width[i]
-          max_col_width[i] = f.to_s.length
+        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

data/lib/ruport/formatter.rb

@@ -26,7 +26,6 @@ module Ruport
   #
   #   class ReverseRenderer < Ruport::Renderer
   #      stage :reversed_header, :reversed_body 
-  #      option :header_text
   #   end
   #                                            
   #   class ReversedText < Ruport::Formatter 
@@ -159,16 +158,26 @@ module Ruport
           formats << format unless formats.include?(format)
         end    
       end
-    end   
+    end
     
-    # Allows the options specified to be accessed directly.
+    # Allows you to implement stages in your formatter using the
+    # following syntax:
+    #
+    #   class ReversedText < Ruport::Formatter 
+    #      renders :txt, :for => ReverseRenderer
+    #      
+    #      build :reversed_header do
+    #         output << "#{options.header_text}\n"
+    #         output << "The reversed text will follow\n"
+    #      end
     # 
-    #   opt_reader :something
-    #   something == options.something #=> true
-    def self.opt_reader(*opts) 
-      require "forwardable"
-      extend Forwardable
-      opts.each { |o| def_delegator :@options, o }
+    #      build :reversed_body do
+    #         output << data.reverse << "\n"
+    #      end
+    #   end
+    #
+    def self.build(stage,&block)
+      define_method "build_#{stage}", &block
     end
     
     # Gives a list of formats registered for this formatter.
@@ -178,7 +187,7 @@ module Ruport
     
     # Returns the template currently set for this formatter.
     def template
-      Template[options.template]
+      Template[options.template] rescue nil || Template[:default]
     end
 
     # Stores a string used for outputting formatted data.
@@ -202,13 +211,20 @@ module Ruport
       File.open(filename,"w") {|f| f << output }
     end
     
+    # Use to define that your formatter should save in binary format
+    def self.save_as_binary_file
+      define_method :save_output do |filename|
+        File.open(filename,"wb") {|f| f << output }
+      end
+    end
+    
     # Evaluates the string using ERB and returns the results.
     #
     # If <tt>:binding</tt> is specified, it will evaluate the template
     # in that context.
     def erb(string,options={})      
       require "erb"
-      if string =~ /\.r\w+$/
+      if string =~ /(\.r\w+)|(\.erb)$/
         ERB.new(File.read(string)).result(options[:binding]||binding)
       else
         ERB.new(string).result(options[:binding]||binding)

data/lib/ruport/renderer/grouping.rb

@@ -30,9 +30,6 @@ module Ruport
   # * build_group_footer
   #
   class Renderer::Group < Renderer
-
-    option :show_table_headers
-
     options { |o| o.show_table_headers = true }
 
     stage :group_header, :group_body, :group_footer
@@ -61,9 +58,6 @@ module Ruport
   # * finalize_grouping
   #
   class Renderer::Grouping < Renderer
-
-    option :show_group_headers, :style
-
     options do |o| 
       o.show_group_headers = true 
       o.style = :inline

data/lib/ruport/renderer/table.rb

@@ -18,7 +18,6 @@ module Ruport
   # * build_row
   #
   class Renderer::Row < Renderer
-    option :format_options
     stage :row
   end
 
@@ -44,9 +43,6 @@ module Ruport
   # * finalize_table
   #
   class Renderer::Table < Renderer
-
-    option :show_table_headers, :format_options
-
     options { |o| o.show_table_headers = true }
 
     prepare :table

data/lib/ruport/renderer.rb

@@ -25,7 +25,10 @@ class Ruport::Renderer
   
   # Structure for holding renderer options.  
   # Simplified version of HashWithIndifferentAccess
-  class Options < OpenStruct  
+  class Options < OpenStruct 
+    
+    private :id
+    
     # Returns a Hash object.  Use this if you need methods other than []
     def to_hash
       @table
@@ -172,49 +175,16 @@ class Ruport::Renderer
             respond_to?(:renderable_data) ? renderable_data(format) : self
           yield(rend) if block_given?  
       end
-    end  
-  end
-  
-  
-  module AutoRunner  #:nodoc:
-    # 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?
-            raise RequiredOptionNotSet, "Required option #{opt} not set"
-          end
-        end
-      end
-
-      if formatter.respond_to?(:apply_template) && options.template
-        formatter.apply_template  
-      end       
-
-      prepare self.class.first_stage if self.class.first_stage
-                
-      if formatter.respond_to?(:layout)  && options.layout != false
-        formatter.layout do execute_stages end
-      else
-        execute_stages
-      end
-
-      finalize self.class.final_stage if self.class.final_stage
-    end  
+    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}")
-        end
-      end
+    def save_as(file,options={})
+      file =~ /.*\.(.*)/    
+      format = $1
+      as(format.to_sym, options.merge(:file => file))        
     end
   end
   
+  
   class << self
     
     attr_accessor :first_stage,:final_stage,:required_options,:stages #:nodoc: 
@@ -311,28 +281,6 @@ class Ruport::Renderer
       }
     end
      
-    # Defines attribute writers for the Renderer::Options object shared
-    # between Renderer and Formatter.
-    #
-    # usage:
-    #   
-    #   class MyRenderer < Ruport::Renderer
-    #      option :font_size, :font_style
-    #      # other details omitted
-    #   end
-    def option(*opts)       
-      opts.each do |opt|                                  
-        o = opt 
-        unless instance_methods(false).include?(o.to_s)   
-          define_method(o) {
-             options.send(o.to_s) 
-          }     
-        end
-        opt = "#{opt}="
-        define_method(opt) {|t| options.send(opt, t) }
-      end
-    end
-    
     # Defines attribute writers for the Renderer::Options object shared
     # between Renderer and Formatter. Will throw an error if the user does
     # not provide values for these options upon rendering.
@@ -347,10 +295,15 @@ class Ruport::Renderer
       self.required_options ||= []
       opts.each do |opt|
         self.required_options << opt 
-        option opt
+
+        o = opt
+        unless instance_methods(false).include?(o.to_s)
+          define_method(o) { options.send(o.to_s) }
+        end
+        opt = "#{opt}="
+        define_method(opt) {|t| options.send(opt, t) }
       end
     end
-    
 
     # Lists the formatters that are currently registered on a renderer,
     # as a hash keyed by format name.
@@ -372,15 +325,10 @@ class Ruport::Renderer
     #   * 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 renderer has defined a run() method, call it. Otherwise,
-    #     include Renderer::AutoRunner (you usually won't need a run() method).
-    #   * Call _run_ if it exists (this is provided by default, by AutoRunner).
+    #   * 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
     #
-    # Note that the only time you will need a run() method is if you can't
-    # do what you need to via a helpers module or via setup()
-    #
     # Please see the examples/ directory for custom renderer examples, because
     # this is not nearly as complicated as it sounds in most cases.
     def render(*args)
@@ -388,12 +336,7 @@ class Ruport::Renderer
           yield(r) if block_given?   
         r.setup if r.respond_to? :setup
       }  
-      if rend.respond_to? :run
-        rend.run
-      else
-        include AutoRunner
-      end
-      rend._run_ if rend.respond_to? :_run_
+      rend.run
       rend.formatter.save_output(rend.options.file) if rend.options.file
       return rend.formatter.output
     end
@@ -411,6 +354,8 @@ class Ruport::Renderer
       return @options
     end
 
+    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
     # yielded.  
@@ -435,8 +380,6 @@ class Ruport::Renderer
       return rend
     end
     
-    private
-    
     # Allows you to register a format with the renderer.
     #
     # Example:
@@ -474,6 +417,12 @@ class Ruport::Renderer
     formatter.options
   end
   
+  # Call the _run_ method.  You can override this method in your custom
+  # renderer 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
   # can use any object that supports the << method, but it's meant
@@ -504,6 +453,43 @@ class Ruport::Renderer
   
   private  
 
+  # 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?
+          raise RequiredOptionNotSet, "Required option #{opt} not set"
+        end
+      end
+    end
+
+    if formatter.respond_to?(:apply_template) && options.template != false
+      formatter.apply_template if options.template ||
+        Ruport::Formatter::Template.default
+    end
+
+    prepare self.class.first_stage if self.class.first_stage
+              
+    if formatter.respond_to?(:layout)  && options.layout != false
+      formatter.layout do execute_stages end
+    else
+      execute_stages
+    end
+
+    finalize self.class.final_stage if self.class.final_stage
+  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}")
+      end
+    end
+  end
+
   def prepare(name)
     maybe "prepare_#{name}"
   end

data/lib/ruport.rb

@@ -12,7 +12,7 @@
 
 module Ruport #:nodoc:#
   
-  VERSION = "1.2.3"   
+  VERSION = "1.4.0"   
   
   class FormatterError < RuntimeError #:nodoc:
   end
@@ -105,8 +105,11 @@ require "enumerator"
 require "ruport/renderer" 
 require "ruport/data" 
 require "ruport/formatter" 
-require "ruport/query" 
 
-if Object.const_defined? :ActiveRecord
-  require "ruport/acts_as_reportable"
+begin
+  if Object.const_defined? :ActiveRecord
+    require "ruport/acts_as_reportable"   
+  end                                     
+rescue LoadError
+  nil
 end

data/test/csv_formatter_test.rb

@@ -11,32 +11,32 @@ end
 class TestRenderCSVTable < Test::Unit::TestCase
   
   def setup
-    Ruport::Formatter::Template.create(:simple) do |t|
-      t.table_format = {
+    Ruport::Formatter::Template.create(:simple) do |format|
+      format.table = {
         :show_headings  => false
       }
-      t.grouping_format = {
+      format.grouping = {
         :style          => :justified,
         :show_headings  => false
       }
-      t.format_options = { :col_sep => ":" }
+      format.format_options = { :col_sep => ":" }
     end
   end
 
   def test_render_csv_table
     actual = Ruport::Renderer::Table.render_csv do |r| 
-      r.data = [[1,2,3],[4,5,6]].to_table 
+      r.data = Table([], :data => [[1,2,3],[4,5,6]])
     end
     assert_equal("1,2,3\n4,5,6\n",actual)
 
     actual = Ruport::Renderer::Table.render_csv do |r|
-      r.data = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+      r.data = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     end
     assert_equal("a,b,c\n1,2,3\n4,5,6\n",actual)
   end   
   
   def test_format_options
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
     assert_equal "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
       a.as(:csv,:format_options => { :col_sep => "\t" })
   end
@@ -44,7 +44,7 @@ class TestRenderCSVTable < Test::Unit::TestCase
   def test_table_headers
     actual = Ruport::Renderer::Table.
              render_csv(:show_table_headers => false, 
-                        :data => [[1,2,3],[4,5,6]].to_table(%w[a b c]))
+                        :data => Table(%w[a b c], :data => [[1,2,3],[4,5,6]]))
     assert_equal("1,2,3\n4,5,6\n",actual)
   end