ruport 1.0.2 → 1.2.0

data/lib/ruport/formatter.rb

@@ -66,7 +66,7 @@ module Ruport
     #
     module RenderingTools
       # Iterates through <tt>data</tt> and passes
-      # each row to render_row with the given options
+      # each row to render_row with the given options.
       def render_data_by_row(options={},&block)
         data.each do |r|
           render_row(r,options,&block)
@@ -124,7 +124,9 @@ module Ruport
       def render_helper(rend_klass, source_data,options={},&block)
         options = {:data => source_data, 
                    :io => output,
-                   :layout => false }.merge(options)
+                   :layout => false }.merge(options)       
+                   
+        options[:io] = "" if self.class.kind_of?(Ruport::Formatter::PDF)
         rend_klass.render(format,options) do |rend|
           block[rend] if block
         end
@@ -140,11 +142,11 @@ module Ruport
     # Set automatically by Renderer#render(format) or Renderer#render_format
     attr_accessor :format                                                    
     
-    # Set automatically by Renderer#render as a Renderer::Options option built
+    # Set automatically by Renderer#render as a Renderer::Options object built
     # by the hash provided.
     attr_writer :options
 
-    # Registers the formatter with one or more Renderers
+    # Registers the formatter with one or more Renderers.
     #
     #   renders :pdf, :for => MyRenderer
     #   render :text, :for => [MyRenderer,YourRenderer]
@@ -172,6 +174,11 @@ module Ruport
     # Gives a list of formats registered for this formatter.
     def self.formats
       @formats ||= []
+    end   
+    
+    # Returns the template currently set for this formatter.
+    def template
+      Template[options.template]
     end
 
     # Stores a string used for outputting formatted data.
@@ -180,15 +187,20 @@ module Ruport
       @output ||= ""
     end
 
-    # Provides a Renderer::Options object for storing formatting options
+    # Provides a Renderer::Options object for storing formatting options.
     def options
       @options ||= Renderer::Options.new
     end 
 
-    # Clears output.
+    # Clears the output.
     def clear_output
       @output.replace("")
-    end   
+    end
+    
+    # Saves the output to a file.
+    def save_output(filename)
+      File.open(filename,"w") {|f| f << output }
+    end
     
     # Evaluates the string using ERB and returns the results.
     #
@@ -203,7 +215,7 @@ module Ruport
       end
     end
 
-    # Provides a shortcut for per format handlers.
+    # Provides a shortcut for per-format handlers.
     #
     # Example:
     #
@@ -218,8 +230,9 @@ module Ruport
       end
     end
   end
-end   
+end                                
 
+require "ruport/formatter/template"
 require "ruport/formatter/csv"
 require "ruport/formatter/html"
 require "ruport/formatter/text"

data/lib/ruport/formatter/csv.rb

@@ -14,8 +14,8 @@
 module Ruport
 
   # This formatter implements the CSV format for Ruport's Row, Table, Group
-  # and Grouping renderers.  It is a light wrapper around James Edward Gray II's
-  # FasterCSV.
+  # and Grouping renderers.  It is a light wrapper around
+  # James Edward Gray II's FasterCSV.
   #
   # === Rendering Options
   #                                                     
@@ -37,6 +37,16 @@ module Ruport
                :show_group_headers,
                :style
 
+    # 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_grouping_format_template(template.grouping_format)
+
+      options.format_options = template.format_options if
+        template.format_options
+    end
+
     # Generates table header by turning column_names into a CSV row.
     # Uses the row renderer to generate the actual formatted output
     #
@@ -82,7 +92,7 @@ module Ruport
       end
     end
    
-    # determines the proper style to use and renders the Grouping.
+    # Determines the proper style to use and renders the Grouping.
     def build_grouping_body
       case style
       when :inline
@@ -110,5 +120,19 @@ module Ruport
         output << "\n"
       end
     end
+    
+    def apply_table_format_template(t)
+      t = t || {}
+      options.show_table_headers = t[:show_headings] unless
+        t[:show_headings].nil?
+    end
+    
+    def apply_grouping_format_template(t)
+      t = t || {}
+      options.style = t[:style] if t[:style]
+      options.show_group_headers = t[:show_headings] unless
+        t[:show_headings].nil?
+    end
+    
   end
 end

data/lib/ruport/formatter/html.rb

@@ -11,9 +11,9 @@
 # See LICENSE and COPYING for details.   
 #
 module Ruport
-  # This class produces HTML output for Ruport's Row,Table,Group, and Grouping
-  # renderers.  It can be used as a subclass, as it has some helper methods
-  # that might be useful for custom output
+  # This class produces HTML output for Ruport's Row, Table, Group, and
+  # Grouping renderers.  It can be subclassed, as it has some helper methods
+  # that might be useful for custom output.
   #
   # === Rendering Options
   #
@@ -30,10 +30,17 @@ module Ruport
 
     opt_reader :show_table_headers, :show_group_headers, :style
     
+    # 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_grouping_format_template(template.grouping_format)
+    end
+
     # Generates table headers based on the column names of your Data::Table.  
     #
-    # This method does not do anything if options.show_table_headers is false or
-    # the Data::Table has no column names.
+    # This method does not do anything if options.show_table_headers is false
+    # or the Data::Table has no column names.
     def build_table_header
       output << "\t<table>\n"
       unless data.column_names.empty? || !show_table_headers
@@ -57,7 +64,7 @@ module Ruport
       output << "\t</table>"
     end
   
-    # Renders individual rows for the table
+    # Renders individual rows for the table.
     def build_row
       output <<
         "\t\t<tr>\n\t\t\t<td>" +
@@ -139,6 +146,19 @@ module Ruport
     def grouping_columns
       data.data.to_a[0][1].column_names
     end
+    
+    def apply_table_format_template(t)
+      t = t || {}
+      options.show_table_headers = t[:show_headings] unless
+        t[:show_headings].nil?
+    end
+    
+    def apply_grouping_format_template(t)
+      t = t || {}
+      options.style = t[:style] if t[:style]
+      options.show_group_headers = t[:show_headings] unless
+        t[:show_headings].nil?
+    end
 
   end
 end

data/lib/ruport/formatter/pdf.rb

@@ -54,9 +54,9 @@ module Ruport
          #p "this actually gets called"
          max_width = PDF::Writer::OHash.new(-1)
 
-           # Find the maximum cell widths based on the data and the headings.
-           # Passing through the data multiple times is unavoidable as we must do
-           # some analysis first.
+         # Find the maximum cell widths based on the data and the headings.
+         # Passing through the data multiple times is unavoidable as we must
+         # do some analysis first.
          @data.each do |row|
            @cols.each do |name, column|
              w = pdf.text_width(row[name].to_s, @font_size)
@@ -82,8 +82,7 @@ module Ruport
     
     attr_writer :pdf_writer
 
-    opt_reader  :show_table_headers,
-                :style,
+    opt_reader  :style,
                 :table_format,
                 :text_format,
                 :paper_size,
@@ -95,6 +94,17 @@ module Ruport
         require "pdf/simpletable"
       end
     end
+    
+    # Hook for setting available options using a template. See the template 
+    # documentation for the available options and their format.
+    def apply_template
+      apply_page_format_template(template.page_format)
+      apply_text_format_template(template.text_format)
+      apply_table_format_template(template.table_format)
+      apply_column_format_template(template.column_format)
+      apply_heading_format_template(template.heading_format)
+      apply_grouping_format_template(template.grouping_format)
+    end
 
     # Returns the current PDF::Writer object or creates a new one if it has not
     # been set yet.
@@ -119,18 +129,18 @@ module Ruport
       render_pdf unless options.skip_finalize_table
     end
     
-    # Generates a header with the group name for Renderer::Group
+    # Generates a header with the group name for Renderer::Group.
     def build_group_header
       pad(10) { add_text data.name.to_s, :justification => :center }
     end
     
-    # Renders the group as a table for Renderer::Group
+    # Renders the group as a table for Renderer::Group.
     def build_group_body
       render_table data, options.to_hash.merge(:formatter => pdf_writer)
     end
                      
     # Determines which style to use and renders the main body for
-    # Renderer::Grouping
+    # Renderer::Grouping.
     def build_grouping_body 
       case style
       when :inline
@@ -145,13 +155,13 @@ module Ruport
       end
     end
    
-    # calls <tt>render_pdf</tt> 
+    # Calls <tt>render_pdf</tt>.
     def finalize_grouping
       render_pdf
     end
 
-    # Call PDF::Writer#text with the given arguments, using <tt>text_format</tt>
-    # defaults, if they are defined.                                       
+    # Call PDF::Writer#text with the given arguments, using
+    # <tt>text_format</tt> defaults, if they are defined.                                       
     #
     # Example:
     #
@@ -164,7 +174,7 @@ module Ruport
       pdf_writer.text(text, format_opts)
     end
 
-    # Calls PDF::Writer#render and appends to <tt>output</tt>
+    # Calls PDF::Writer#render and appends to <tt>output</tt>.
     def render_pdf
       output << pdf_writer.render
     end
@@ -196,7 +206,7 @@ module Ruport
       pdf_writer.add_image_from_file(path, x, y, img_width, img_height) 
     end
 
-    # Draws some text on the canvas, surrounded by a box with rounded corner
+    # Draws some text on the canvas, surrounded by a box with rounded corners.
     #
     # Yields an OpenStruct which options can be defined on.
     # 
@@ -254,22 +264,22 @@ module Ruport
       end
     end
     
-    # adds n to pdf_writer.y, moving the vertical drawing position in the
-    # document 
+    # Adds n to pdf_writer.y, moving the vertical drawing position in the
+    # document.
     def move_cursor(n) 
       pdf_writer.y += n
     end
     
-    # moves the cursor to a specific y coordinate in the document
+    # Moves the cursor to a specific y coordinate in the document.
     def move_cursor_to(n)
       pdf_writer.y = n
     end
     
-    # puts a specified amount of whitespace above and below the code
+    # Adds a specified amount of whitespace above and below the code
     # in your block.  For example, if you want to surround the top and
     # bottom of a line of text with 5 pixels of whitespace:
     #
-    #    pad(5) { add_text "This will be padded" }
+    #    pad(5) { add_text "This will be padded top and bottom" }
     def pad(y,&block)
       move_cursor(-y)
       block.call
@@ -290,13 +300,13 @@ module Ruport
     # For example, if you want to add a 10 pixel buffer to the bottom of a
     # line of text:
     #
-    #    pad_bottom(10) { add_text "This will be padded on top" }
+    #    pad_bottom(10) { add_text "This will be padded on bottom" }
     def pad_bottom(y,&block)
       block.call
       move_cursor(-y)
     end
     
-    # Draws a PDF::SimpleTable using the given data (usually a Data::Table)
+    # Draws a PDF::SimpleTable using the given data (usually a Data::Table).
     # Takes all the options you can set on a PDF::SimpleTable object,
     # see the PDF::Writer API docs for details, or check our quick reference
     # at: 
@@ -327,25 +337,30 @@ module Ruport
       pdf_writer.font_size = old
     end
     
-    # This module provides tools to simplify some common drawing operations
-    # it is included by default in the PDF formatter
+    # Save the output to a file.
+    def save_output(filename)
+      File.open(filename,"wb") {|f| f << output }
+    end
+    
+    # This module provides tools to simplify some common drawing operations.
+    # It is included by default in the PDF formatter.
     #
     module DrawingHelpers
       
-      # draws a horizontal line from x1 to x2
+      # Draws a horizontal line from x1 to x2
       def horizontal_line(x1,x2)
         pdf_writer.line(x1,cursor,x2,cursor)
         pdf_writer.stroke
       end 
       
-      # draws a horizontal line from left_boundary to right_boundary
+      # Draws a horizontal line from left_boundary to right_boundary
       def horizontal_rule
         horizontal_line(left_boundary,right_boundary)                                            
       end                                            
       
       alias_method :hr, :horizontal_rule
                     
-      # draws a vertical line at x from y1 to y2
+      # Draws a vertical line at x from y1 to y2
       def vertical_line_at(x,y1,y2)
         pdf_writer.line(x,y1,x,y2)
         pdf_writer.stroke 
@@ -377,33 +392,82 @@ module Ruport
       end
       
       # Draws text at an absolute location, defined by
-      # :y, :x1|:left, :x2|:right 
+      # :y, :x1|:left, :x2|:right
       # 
-      # All usual options to add_text are also supported
+      # All options to add_text are also supported.
       def draw_text(text,text_opts)
+        ypos = cursor
         move_cursor_to(text_opts[:y]) if text_opts[:y]
         add_text(text,
           text_opts.merge(:absolute_left => text_opts[:x1] || text_opts[:left],
           :absolute_right => text_opts[:x2] || text_opts[:right]))
+        move_cursor_to(ypos)
       end
       
+      # Draws text at an absolute location, defined by
+      # :y, :x1|:left
+      #
+      # The x position defaults to the left margin and the
+      # y position defaults to the current cursor location.
+      # 
+      # Uses PDF::Writer#add_text, so it will ignore any options not supported
+      # by that method.
+      def draw_text!(text,text_opts)
+        ypos = cursor
+        pdf_writer.add_text(text_opts[:x1] || text_opts[:left] || left_boundary,
+          text_opts[:y] || ypos,
+          text,
+          text_opts[:font_size],
+          text_opts[:angle] || 0)
+        move_cursor_to(ypos)
+      end
     end   
 
     include DrawingHelpers
     
-    private   
+    private
     
     def apply_pdf_table_column_opts(table,table_data,format_opts)
-      column_opts = format_opts.delete(:column_options)           
-      if column_opts                                              
-        columns = table_data.column_names.inject({}) { |s,c| 
-          s.merge( c => ::PDF::SimpleTable::Column.new(c) { |col| 
-            column_opts.each { |k,v| col.send("#{k}=",v) } 
+      column_opts = format_opts.delete(:column_options)
+
+      if column_opts
+        heading_opts = column_opts.delete(:heading)
+        if column_opts[:justification]
+          heading_opts ||= {}
+          heading_opts = {
+            :justification => column_opts[:justification]
+          }.merge(heading_opts)
+        end
+        specific = get_specific_column_options(table_data.column_names,
+                                               column_opts)
+        columns = table_data.column_names.inject({}) { |s,c|
+          s.merge( c => ::PDF::SimpleTable::Column.new(c) { |col|
+            col.heading = create_heading(heading_opts) 
+            column_opts.each { |k,v| col.send("#{k}=",v) }
+            # use the specific column names now
+            specific[c].each { |k,v| col.send("#{k}=",v) }
           })
-        }                     
+        }
         table.columns = columns
-      end    
-    end      
+      end
+    end
+
+    def get_specific_column_options(column_names,column_opts)
+      column_names.inject({}) do |s,c|
+        opts = column_opts.delete(c) || {}
+        if opts[:heading]
+          opts = opts.merge(:heading => create_heading(opts[:heading]))
+        end
+        s.merge(c => opts)
+      end
+    end
+    
+    def create_heading(heading_opts)
+      heading_opts ||= {}
+      ::PDF::SimpleTable::Column::Heading.new {|head|
+        heading_opts.each {|k,v| head.send("#{k}=",v) }
+      }
+    end
     
     def grouping_columns
       data.data.to_a[0][1].column_names.dup.unshift(data.grouped_by)
@@ -487,5 +551,74 @@ module Ruport
         :justification => :center, :font_size => font_size)
     end
     
+    def apply_page_format_template(t)
+      t = t || {}
+      options.paper_size = t[:size] if t[:size]
+      options.paper_orientation = t[:layout] if t[:layout]
+    end
+    
+    def apply_text_format_template(t)
+      options.text_format = template.text_format if t
+    end
+
+    def apply_table_format_template(t)
+      options.table_format = template.table_format.dup if t
+    end
+    
+    def apply_column_format_template(t)
+      t = t || {}
+      column_opts = {}
+      column_opts.merge!(:justification => t[:alignment]) if t[:alignment]
+      column_opts.merge!(:width => t[:width]) if t[:width]
+      unless column_opts.empty?
+        if options.table_format
+          if options.table_format[:column_options]
+            options.table_format[:column_options] =
+              column_opts.merge(options.table_format[:column_options])
+          else
+            options.table_format.merge!(:column_options => column_opts)
+          end
+        else
+          options.table_format = { :column_options => column_opts }
+        end
+      end
+    end
+    
+    def apply_heading_format_template(t)
+      t = t || {}
+      heading_opts = {}
+      heading_opts.merge!(:justification => t[:alignment]) if t[:alignment]
+      heading_opts.merge!(:bold => t[:bold]) unless t[:bold].nil?
+      heading_opts.merge!(:title => t[:title]) if t[:title]
+      unless heading_opts.empty?
+        if options.table_format
+          if options.table_format[:column_options]
+            if options.table_format[:column_options][:heading]
+              options.table_format[:column_options][:heading] =
+                heading_opts.merge(
+                  options.table_format[:column_options][:heading]
+                )
+            else
+              options.table_format[:column_options].merge!(
+                :heading => heading_opts
+              )
+            end
+          else
+            options.table_format.merge!(
+              :column_options => { :heading => heading_opts }
+            )
+          end
+        else
+          options.table_format = {
+            :column_options => { :heading => heading_opts }
+          }
+        end
+      end
+    end
+    
+    def apply_grouping_format_template(t)
+      t = t || {}
+      options.style = t[:style] if t[:style]
+    end
   end
 end