ruport 0.7.2 → 0.8.0

data/lib/ruport/data/taggable.rb

@@ -5,7 +5,8 @@
 # Copyright 2006 by respective content owners, all rights reserved.
 module Ruport::Data
   
-
+  require 'set'  
+  #
   # === Overview
   # 
   # This module provides a simple mechanism for tagging arbitrary objects.  
@@ -14,6 +15,7 @@ module Ruport::Data
   #
   module Taggable
 
+    #
     # Adds a tag to the object.
     #
     # Example:
@@ -21,9 +23,10 @@ module Ruport::Data
     #   taggable_obj.tag :spiffy
     #
     def tag(tag_name)
-      tags << tag_name unless has_tag? tag_name
+      tags << tag_name 
     end
     
+    #
     # Removes a tag from the object.
     #
     # Example:
@@ -34,6 +37,7 @@ module Ruport::Data
       tags.delete tag_name
     end
   
+    #
     # Checks to see if a tag is present.
     #
     # Example:
@@ -44,24 +48,31 @@ module Ruport::Data
       tags.include? tag_name
     end
   
+    # 
     # Returns an Array of the object's tags.
     #
     # Example:
     #
     #   taggable_obj.tags #=> [:spiffy, :kind_of_spiffy]
     #
-    def tags
-      @ruport_tags ||= []
+    def tags              
+      @ruport_tags ||= Set.new
     end
    
-    # Sets the tags to some Array.
+    # 
+    # Sets the tags.
     #
     # Example:
     #
     #   taggable_obj.tags = [:really_dang_spiffy, :the_most_spiffy]
     #
-    def tags=(tags_list)
-      @ruport_tags = tags_list
+    def tags=(tags_list)     
+      case tags_list
+      when Array
+        @ruport_tags = Set.new(tags_list)
+      else
+        @ruport_tags = tags_list
+      end
     end
 
   end

data/lib/ruport/format/html.rb

@@ -24,7 +24,9 @@ module Ruport::Format
     def build_table_body
       output << data.inject("") do |s,r| 
         row = r.map { |e| e.to_s.empty? ? "&nbsp;" : e }
-        classstr = r.tags.inject("") {|cs,c| cs + " class='#{c}'" } 
+        #classstr = r.tags.inject("") {|cs,c| cs + " class='#{c}'" }   
+        classstr = 
+          r.tags.length > 0 ? " class='#{r.tags.to_a.join(' ')}'" : ""
         s + "\t\t<tr#{classstr}>\n\t\t\t<td#{classstr}>" +
           row.to_a.join("</td>\n\t\t\t<td#{classstr}>") + 
           "</td>\n\t\t</tr>\n"

data/lib/ruport/format/latex.rb

@@ -30,7 +30,7 @@ module Ruport::Format
 
     def build_table_body
       data.each do |r|
-        output << r.data.join(" & ") + "\\\\\n"
+        output << r.to_a.join(" & ") + "\\\\\n"
         output << "\\hline\n"
       end
       if caption

data/lib/ruport/format/latex.rb.rej

@@ -0,0 +1,26 @@
+***************
+*** 15,27 ****
+          output << " }\n"
+          output << "\\hline\n"
+  
+-         #FIXME: this ain't ruby, jh ;)
+-         counter = 0
+- 
+-         data.column_names.each do |t|
+-           output << " & " unless counter == 0
+            output << "\\textsc{#{t}}"
+-           counter += 1
+          end
+  
+          output << "\\\\\n"
+--- 15,24 ----
+          output << " }\n"
+          output << "\\hline\n"
+  
++         output << "\\textsc{#{data.column_names[0]}}"
++         data.column_names[1..-1].each do |t|
++           output << " & "
+            output << "\\textsc{#{t}}"
+          end
+  
+          output << "\\\\\n"

data/lib/ruport/format/latex.rb~

@@ -0,0 +1,47 @@
+module Ruport::Format
+  class Latex < Plugin
+
+    attr_accessor :caption
+    
+    def build_table_header
+      output << "\\documentclass[11pt]{article}\n"     <<
+                "\\RequirePackage{lscape,longtable}\n" <<
+                "\\begin{document}\n" <<
+                "\\begin{longtable}[c]{ "
+        
+        data.column_names.each do
+          output << " p{2cm} "
+        end
+        output << " }\n"
+        output << "\\hline\n"
+
+        output << "\\textsc{#{data.column_names[0]}}"
+        data.column_names[1..-1].each do |t|
+          output << " & "
+          output << "\\textsc{#{t}}"
+        end
+
+        output << "\\\\\n"
+        output << "\\hline\n"
+        output << "\\endhead\n"
+        output << "\\endfoot\n"
+        output << "\\hline\n"
+    end
+
+    def build_table_body
+      data.each do |r|
+        output << r.to_a.join(" & ") + "\\\\\n"
+        output << "\\hline\n"
+      end
+      if caption
+        output << "\\caption[#{caption}]{#{caption}}\n"
+      end
+      output << "\\end{longtable}\n"
+    end
+
+    def build_table_footer
+      output << "\\end{document}\n"
+    end
+
+  end
+end

data/lib/ruport/format/pdf.rb

@@ -11,10 +11,6 @@ module Ruport::Format
   #       * table_width
   #       * max_table_width #=> 500
   #
-  # This class makes extensive use of Austin Zeigler's PDF::Writer
-  # Please refer to the API documentation for PDF::Writer if you need more
-  # information.
-  #
   class PDF < Plugin
     attr_writer :pdf_writer
     attr_accessor :table_header_proc
@@ -77,45 +73,132 @@ module Ruport::Format
     def add_text(*args)
       pdf_writer.text(*args)
     end
+       
+    # - if the image is bigger than the box, it will be scaled down until it fits
+    # - if the image is smaller than the box it's won't be resized
+    #
+    # arguments:
+    # - x: left bound of box
+    # - y: bottom bound of box
+    # - width: width of box
+    # - height: height of box
+    def center_image_in_box(path, x, y, width, height)
+      info = ::PDF::Writer::Graphics::ImageInfo.new(File.read(path))
+
+      # if the image is larger than the requested box, prepare to
+      # scale it down
+      fits = !(info.width > width || info.height > height)
+
+      # setup initial sizes for the image. These will be reduced as necesary
+      img_width = info.width
+      img_height = info.height
+      img_ratio = info.height.to_f / info.width.to_f
+
+      # reduce the size of the image until it fits into the requested box
+      until fits
+        img_width -= 1
+        img_height = img_width * img_ratio
+        fits = true if img_width < width && img_height < height
+      end
+
+      # if the width of the image is less than the requested box, calculate
+      # the white space buffer
+      if img_width < width
+        white_space = width - img_width
+        x = x + (white_space / 2)
+      end
+
+      # if the height of the image is less than the requested box, calculate
+      # the white space buffer
+      if img_height < height
+        white_space = height - img_height
+        y = y + (white_space / 2)
+      end
+
+      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 corners
+    #
+    def rounded_text_box(text)
+       opts = OpenStruct.new
+       yield(opts)
+       
+       # resize the text automatically to ensure it isn't wider than the box
+       loop do
+         sz = pdf_writer.text_width( text, opts.font_size )
+         opts.x + sz > opts.x + opts.width or break
+         opts.font_size -= 1
+       end
+
+       # save the drawing state (colors, etc) so we can restore it later
+       pdf_writer.save_state
+
+       # draw our box
+       pdf_writer.fill_color(opts.fill_color || Color::RGB::White)
+       pdf_writer.stroke_color(opts.stroke_color || Color::RGB::Black)
+       pdf_writer.rounded_rectangle( opts.x, opts.y, 
+                                     opts.width, opts.height, 
+                                     opts.radius).fill_stroke
+
+       # if a heading for this box has been specified
+       if opts.heading
+         pdf_writer.line( opts.x, opts.y - 20, 
+                          opts.x + opts.width, opts.y - 20).stroke
+         pdf_writer.fill_color(Color::RGB::Black)
+         move_cursor_to(opts.y - 3)
+         add_text("<b>#{opts.heading}</b>", 
+           :absolute_left => opts.x, :absolute_right => opts.x + opts.width,
+           :justification => :center, :font_size => opts.font_size)
+       end
+
+       # restore the original colors
+       pdf_writer.restore_state
+
+       # move our y cursor into position, write the text, then move the cursor
+       # to be just below the box
+       pdf_writer.y = opts.heading ? opts.y - 20 : opts.y
+
+       add_text( text,  :absolute_left  => opts.x,
+                        :absolute_right => opts.x + opts.width,
+                        :justification => opts.justification || :center,
+                        :font_size => opts.font_size )     
+
+       pdf_writer.y = opts.y - opts.height
+    end
+
+    # adds an image to every page. The color and size won't be modified,
+    # but it will be centered.
+    #
+    def watermark(imgpath)
+      x = pdf_writer.absolute_left_margin
+      y = pdf_writer.absolute_bottom_margin
+      width = pdf_writer.absolute_right_margin - x
+      height = pdf_writer.absolute_top_margin - y
+
+      pdf_writer.open_object do |wm|
+        pdf_writer.save_state
+        center_image_in_box(imgpath, x, y, width, height)
+        pdf_writer.restore_state
+        pdf_writer.close_object
+        pdf_writer.add_object(wm, :all_pages)
+      end
+    end
 
-    # Adds n to PDF::Writer#y.
-    #
-    # Basically, this allows you to move the rendering cursor up and down the page.
-    #
-    #    move_cursor(10)  #=>  move up 10 
-    #   move_cursor(-10)  #=> move down 10
     def move_cursor(n) 
       pdf_writer.y += n
     end
 
-    # Sets PDF::Writer#y to n.
-    #
-    # This lets you move to a given height on the page.
-    #
     def move_cursor_to(n)
       pdf_writer.y = n
     end
 
-    # creates a margin of <tt>y</tt> amount and allows a block to be called to
-    # render items within that margin.
-    #
-    # Example:
-    #
-    # pad(10) { add_text 'hello' } #=> creates text hello with vertical margin
-    # of 10.
     def pad(y,&block)
       move_cursor -y
       block.call
       move_cursor -y
     end
 
-    # Builds a PDF::SimpleTable from a Data::Table
-    # 
-    # Can be customized via the follow layout parameters:
-    #
-    #   max_table_width  #=> defaults to 500
-    #   table_width      #=> optionally set a fixed width for the table
-    #   orientation      #=> defaults to :center
     def draw_table
       m = "Sorry, cant build PDFs from array like things (yet)"
       raise m if data.column_names.empty?

data/lib/ruport/format/pdf.rb.rej

@@ -0,0 +1,168 @@
+***************
+*** 11,65 ****
+    #       * table_width
+    #       * max_table_width #=> 500
+    #
+    class PDF < Plugin
+      attr_writer :pdf_writer
+      attr_accessor :table_header_proc
+      attr_accessor :table_footer_proc
+  
+      def initialize
+        require "pdf/writer"
+        require "pdf/simpletable"
+      end
+  
+      def pdf_writer
+        @pdf_writer ||= 
+          ::PDF::Writer.new( :paper => layout.paper_size || "LETTER" )
+      end
+  
+      def build_table_header
+         table_header_proc[pdf_writer] if table_header_proc
+      end
+  
+      def build_table_body
+        draw_table
+      end
+  
+      def build_table_footer
+        table_footer_proc[pdf_writer] if table_footer_proc
+      end
+  
+      def finalize_table
+        output << pdf_writer.render
+      end
+  
+      def add_text(*args)
+        pdf_writer.text(*args)
+      end
+  
+      def move_cursor(n) 
+        pdf_writer.y += n
+      end
+  
+      def move_cursor_to(n)
+        pdf_writer.y = n
+      end
+  
+      def pad(y,&block)
+        move_cursor -y
+        block.call
+        move_cursor -y
+      end
+  
+      def draw_table
+        m = "Sorry, cant build PDFs from array like things (yet)"
+        raise m if data.column_names.empty?
+--- 11,120 ----
+    #       * table_width
+    #       * max_table_width #=> 500
+    #
++   # This class makes extensive use of Austin Zeigler's PDF::Writer
++   # Please refer to the API documentation for PDF::Writer if you need more
++   # information.
++   #
+    class PDF < Plugin
+      attr_writer :pdf_writer
+      attr_accessor :table_header_proc
+      attr_accessor :table_footer_proc
+  
++     # Does the necessary PDF::Writer requires
+      def initialize
+        require "pdf/writer"
+        require "pdf/simpletable"
+      end
+  
++     # Returns the current PDF::Writer object or creates a new one if it has not
++     # been set yet.
++     #
+      def pdf_writer
+        @pdf_writer ||= 
+          ::PDF::Writer.new( :paper => layout.paper_size || "LETTER" )
+      end
+  
++     # If table_header_proc is defined, it will be executed and the PDF::Writer
++     # object will be yielded.
++     #
++     # This should be overridden by subclasses, or used as a shortcut for your
++     # own plugin implementations
++     #
++     # This method is automatically called by the table renderer
++     #
+      def build_table_header
+         table_header_proc[pdf_writer] if table_header_proc
+      end
+  
++     # Calls the draw_table method
++     #
++     # This method is automatically called by the table renderer
++     #
+      def build_table_body
+        draw_table
+      end
+  
++     # If table_footer_proc is defined, it will be executed and the PDF::Writer
++     # object will be yielded.
++     #
++     # This should be overridden by subclasses, or used as a shortcut for your
++     # own plugin implementations
++     #
++     # This method is automatically called by the table renderer
++     #
+      def build_table_footer
+        table_footer_proc[pdf_writer] if table_footer_proc
+      end
+  
++     # Appends the results of PDF::Writer#render to output for your 
++     # <tt>pdf_writer</tt> object.
+      def finalize_table
+        output << pdf_writer.render
+      end
+  
++     # Call PDF::Writer#text with the given arguments
+      def add_text(*args)
+        pdf_writer.text(*args)
+      end
+  
++     # Adds n to PDF::Writer#y.
++     #
++     # Basically, this allows you to move the rendering cursor up and down the page.
++     #
++     #    move_cursor(10)  #=>  move up 10 
++     #   move_cursor(-10)  #=> move down 10
+      def move_cursor(n) 
+        pdf_writer.y += n
+      end
+  
++     # Sets PDF::Writer#y to n.
++     #
++     # This lets you move to a given height on the page.
++     #
+      def move_cursor_to(n)
+        pdf_writer.y = n
+      end
+  
++     # creates a margin of <tt>y</tt> amount and allows a block to be called to
++     # render items within that margin.
++     #
++     # Example:
++     #
++     # pad(10) { add_text 'hello' } #=> creates text hello with vertical margin
++     # of 10.
+      def pad(y,&block)
+        move_cursor -y
+        block.call
+        move_cursor -y
+      end
+  
++     # Builds a PDF::SimpleTable from a Data::Table
++     # 
++     # Can be customized via the follow layout parameters:
++     #
++     #   max_table_width  #=> defaults to 500
++     #   table_width      #=> optionally set a fixed width for the table
++     #   orientation      #=> defaults to :center
+      def draw_table
+        m = "Sorry, cant build PDFs from array like things (yet)"
+        raise m if data.column_names.empty?