ruport 0.5.4 → 0.6.0

data/lib/ruport/format.rb

@@ -75,6 +75,10 @@ module Ruport
           options[:auto_render] = false; simple_interface(engine,options) })
     end
 
+    %w[engine plugin].each { |lib|
+       require "ruport/format/#{lib}" 
+    }
+
     @@filters = Hash.new
     
     # To hook up a Format object to your current class, you need to pass it a
@@ -147,7 +151,9 @@ module Ruport
         
         options[:auto_render] ? my_engine.render : my_engine.dup
       end
+
+
+    
   end
 end
 
-%w[engine plugin].each { |lib| require "ruport/format/#{lib}" }

data/lib/ruport/format/engine/table.rb

@@ -5,7 +5,8 @@ module Ruport
        renderer do
           super
           active_plugin.rendered_field_names = "" 
-          build_field_names if (data.respond_to?(:column_names) && 
+          build_field_names if (data.respond_to?(:column_names) &&
+                                !data.column_names.empty? &&
                                 data.column_names && show_field_names)
           a = active_plugin.render_table
        end

data/lib/ruport/format/plugin.rb

@@ -47,14 +47,14 @@ module Ruport
         singleton_class.send( :define_method, :build_field_names, &block)
       end
 
-      def register_on(klass)
-         
-        if klass.kind_of? Symbol
-          klass = Format::Engine.engine_classes[klass]
-        end
-        
-        klass.accept_format_plugin(self)
+      def register_on(*args)
+        args.each { |klass|
+          if klass.kind_of? Symbol
+            klass = Format::Engine.engine_classes[klass]
+          end
         
+          klass.accept_format_plugin(self)
+        }
       rescue NoMethodError
         p caller
       end
@@ -72,5 +72,5 @@ module Ruport
     end
   end       
 end
-plugins = %w[text csv pdf svg html]
+plugins = %w[text csv pdf svg html latex]
 plugins.each { |p| require "ruport/format/plugin/#{p}_plugin" }

data/lib/ruport/format/plugin/csv_plugin.rb

@@ -5,7 +5,11 @@ module Ruport
       helper(:init_plugin) { |eng| require "fastercsv" }
 
       format_field_names do
-        FasterCSV.generate { |csv| csv << data.column_names }
+        if data.column_names.empty?
+          ""
+        else
+          FasterCSV.generate { |csv| csv << data.column_names }
+        end
       end
       
       renderer :table do

data/lib/ruport/format/plugin/html_plugin.rb

@@ -2,21 +2,25 @@ module Ruport
   class Format::Plugin
     class HTMLPlugin < Format::Plugin
    
-      rendering_options :red_cloth_enabled => true, 
-                        :erb_enabled => true
-     
+      rendering_options :red_cloth_enabled => true, :erb_enabled => true
+
       renderer :document 
       
       renderer :table do
-        rc = data.inject(rendered_field_names) { |s,r| 
+        data.inject("\t<table>\n" + rendered_field_names) do |s,r| 
           row = r.map { |e| e.to_s.empty? ? "&nbsp;" : e }
-          s + "|#{row.to_a.join('|')}|\n" 
-        }
-        Format.document :data => rc, :plugin => :html 
+          classstr = defined?(r.tags) ? 
+            r.tags.inject("") {|cs,c| cs + " class='#{c}'" } : ""
+          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"
+        end + "\t</table>" 
       end
 
       format_field_names do
-        s = "|_." + data.column_names.join(" |_.") + "|\n"
+        "\t\t<tr>\n\t\t\t<th>" + 
+          data.column_names.join("</th>\n\t\t\t<th>") + 
+          "</th>\n\t\t</tr>\n"
       end
 
       plugin_name :html

data/lib/ruport/format/plugin/latex_plugin.rb

@@ -0,0 +1,50 @@
+module Ruport
+  class Format::Plugin
+   class LatexPlugin < Format::Plugin
+    
+      helper(:init_plugin) { |eng|
+        @report_header = "\\documentclass[11pt]{article}\n"
+        @report_header << "\\RequirePackage{lscape,longtable}\n"
+        @report_header << "\\begin{document}\n"
+
+        @report_footer = "\\end{document}\n"
+      }
+
+      renderer :table do 
+        self.options = {} if self.options.nil?
+
+        @body = "\\begin{longtable}[c]{ "
+        @data.column_names.each do
+          @body << " p{2cm} "
+        end
+        @body << " }\n"
+        @body << "\\hline\n"
+        counter = 0
+        @data.column_names.each do |t|
+          @body << " & " unless counter == 0
+          @body << "\\textsc{#{t}}"
+          counter += 1
+        end
+        @body << "\\\\\n"
+        @body << "\\hline\n"
+        @body << "\\endhead\n"
+        @body << "\\endfoot\n"
+        @body << "\\hline\n"
+        @data.each do |r|
+          @body << r.data.join(" & ") + "\\\\\n"
+          @body << "\\hline\n"
+        end
+        unless options[:caption].nil?
+          @body << "\\caption[#{options[:caption]}]{#{options[:caption]}}\n"
+        end
+        @body << "\\end{longtable}\n"
+
+        @report_header + @body + @report_footer
+      end
+
+      plugin_name :latex
+      register_on :table_engine
+
+    end
+  end
+end

data/lib/ruport/format/plugin/text_plugin.rb

@@ -9,56 +9,61 @@ module Ruport
         require "ruport/system_extensions" 
         
         return "" if data.length == 0; 
-        th = "#{rendered_field_names}#{hr}"
-       
+
+        calculate_max_col_widths
+
+        width = self.right_margin || SystemExtensions.terminal_width
+
+        s = "#{rendered_field_names}#{hr}"
+  
         data.each { |r|
+          line = Array.new
           r.each_with_index { |f,i|
-            r[i] = f.to_s.center(max_col_width(i))
+            line << f.to_s.center(max_col_width[i])
           }
+          s += "| #{line.join(' | ')} |\n"
         }
-        
-        a = data.inject(th){ |s,r|
-          s + "| #{r.to_a.join(' | ')} |\n"
-        } << hr
+        s += hr
 
-        width = self.right_margin || SystemExtensions.terminal_width
-        
-        a.to_a.each { |r|
+        s.split("\n").each { |r|
            r.gsub!(/\A.{#{width+1},}/) { |m| m[0,width-2] + ">>" }
-        }.join
+        }.join("\n") + "\n"
+        
       end
       
       format_field_names do
-        return "" if data.length == 0;
-        data.column_names.each_with_index { |f,i| 
-          data.column_names[i] = f.to_s.center(max_col_width(i))
+        return "" if data.length == 0
+        calculate_max_col_widths
+        c=data.column_names.dup
+        c.each_with_index { |f,i| 
+          c[i] = f.to_s.center(max_col_width[i])
         }
-        "#{hr}| #{data.column_names.to_a.join(' | ')} |\n"
+        "#{hr}| #{c.to_a.join(' | ')} |\n"
       end
 
-      action :max_col_width do |index|
-        f = data.column_names if data.respond_to? :column_names
-        d = Data::Table.new :column_names => f, :data => data
-        
-        cw = d.map { |r| r[index].to_s.length }.max
-        
-        return cw unless d.column_names
-        
-        nw = (index.kind_of?(Integer) ? d.column_names[index] : index ).to_s.length
-        
-        [cw,nw].max
+      action :max_col_width do
+        @max_col_width
       end
 
-      action :table_width do
-        f = data.column_names if data.respond_to? :column_names
-        d = Data::Table.new:column_names => f, :data => data 
-        
-        f = d[0].attributes || (0...d[0].length)
-        f.inject(0) { |s,e| s + max_col_width(e) }
+      action :calculate_max_col_widths do
+        @max_col_width=Array.new
+        if defined?(data.column_names)
+          data.column_names.each_index do |i| 
+            @max_col_width[i] = data.column_names[i].to_s.length
+          end
+        end
+            
+        data.each {|r|
+          r.each_with_index { |f,i|
+            if !max_col_width[i] || f.to_s.length > max_col_width[i]
+              max_col_width[i] = f.to_s.length
+            end
+          }
+        }
       end
 
       action :hr do
-        len = data[0].to_a.length * 3 + table_width + 1
+        len = max_col_width.inject(data[0].to_a.length * 3) {|s,e| s+e} + 1
         "+" + "-"*(len-2) + "+\n"
       end
 

data/lib/ruport/meta_tools.rb

@@ -5,7 +5,7 @@ module Ruport
   # formatting system, and might be helpful for other things.
   #
   module MetaTools
-    # allows you to define an attribute accessor on the singleton_class.
+    # Allows you to define an attribute accessor on the singleton_class.
     #
     # Example:
     # 
@@ -21,14 +21,14 @@ module Ruport
       self.send("#{sym}=",value)
     end
 
-    # same as attribute, but takes an array of attributes
+    # Same as attribute, but takes an array of attributes
     #
     # e.g. attributes [:foo,:bar,:baz]
     def attributes(syms)
       syms.each { |s| attribute s }
     end
     
-    # allows you to define a method on the singleton_class
+    # Allows you to define a method on the singleton_class
     #
     # Example:
     #

data/lib/ruport/query.rb

@@ -59,11 +59,18 @@ module Ruport
     #     :user => "greg", :password => "chunky_bacon" )
     #
     #   # uses a SQL file stored on disk
-    #   Ruport::Query.new("my_query.sql",:origin => :file)
+    #   Ruport::Query.new("my_query.sql")
+    #
+    #   # explicitly use a file, even if it doesn't end in .sql
+    #   Ruport::Query.new("foo",:origin => :file)
     def initialize(sql, options={})
       options = { :source => :default, :origin => :string }.merge(options)
-      @sql = sql
-      @statements = SqlSplit.new(get_query(options[:origin],sql))
+      options[:binding] ||= binding
+      options[:origin] = :file if sql =~ /.sql$/
+      q = Format.document :data => get_query(options[:origin],sql),
+                          :plugin => :text, :class_binding => options[:binding]
+      @statements = SqlSplit.new(q)
+      @sql = @statements.join
       
       if options[:dsn]
         Ruport::Config.source :temp, :dsn      => options[:dsn],
@@ -76,6 +83,7 @@ module Ruport
       
       @raw_data = options[:raw_data]
       @cache_enabled  = options[:cache_enabled]
+      @params = options[:params]
       @cached_data = nil
     end
     
@@ -156,18 +164,22 @@ module Ruport
 
     private
     
-    def query_data( query_text )
+    def query_data( query_text, params=@params )
       
       require "dbi"
       
       data = @raw_data ? [] : Data::Table.new
       DBI.connect(@dsn, @user, @password) do |dbh|
-        dbh.execute(query_text) do |sth|
-            return unless sth.fetchable?
-            results = sth.fetch_all  
-            data.column_names = sth.column_names unless @raw_data
-            results.each { |row| data << row.to_a }
+        if params
+          sth = dbh.execute(query_text,*params)
+        else
+          sth = dbh.execute(query_text)
         end
+        return unless sth.fetchable?
+        results = sth.fetch_all  
+        data.column_names = sth.column_names unless @raw_data
+        results.each { |row| data << row.to_a }
+        sth.finish
       end
       data
       rescue NoMethodError; nil

data/lib/ruport/report.rb

@@ -7,11 +7,11 @@
 
 #load the needed standard libraries.
 %w[erb yaml date logger fileutils].each { |lib| require lib }
-
-require "ruport/report/invoice"
+%w[invoice graph].each { |lib| require "ruport/report/"+lib }
 require "forwardable"
 
 module Ruport
+
   # === Overview
   #
   # The Ruport::Report class povides a high level interface to most of Ruport's
@@ -72,6 +72,7 @@ module Ruport
   class Report   
     extend Forwardable
     
+    include Ruport::Data::TableHelper
     # When initializing a report, you can provide a default mailer and source by
     # giving a name of a valid source or mailer you've defined via
     # Ruport::Config
@@ -131,7 +132,7 @@ module Ruport
     def query(sql, options={})
       options[:origin] ||= :string
       options[:source] ||= @source
-
+      options[:binding] ||= binding
       q = options[:query_obj] || Query.new(sql, options)
       if options[:yield_type].eql?(:by_row)
         q.each { |r| yield(r) }
@@ -178,16 +179,13 @@ module Ruport
       string
     end
     
-    # preserved for backwards compatibility. please do not use.
-    alias_method :render, :process_text
-
     # This allows you to create filters to be used by process_text
     #
     # The block is evaluated in the context of the instance.
     #
     # E.g
     #
-    #  text_processor(:unix_newlines) { results.gsub!(/\r\n/,"\n") }
+    #  text_processor(:unix_newlines) { |r| r.gsub(/\r\n/,"\n") }
     def text_processor(label,&block)
       Format.register_filter(label, &block)
     end
@@ -196,8 +194,8 @@ module Ruport
     # Writes the contents of <tt>results</tt> to file.  If a filename is
     # specified, it will use it.  Otherwise, it will try to write to the file
     # specified by the <tt>file</tt> attribute.
-    def write(my_file=file)
-      File.open(my_file,"w") { |f| f << results }
+    def write(my_file=file,my_results=results)
+      File.open(my_file,"w") { |f| f << my_results }
     end
 
     # Like Report#write, but will append to a file rather than overwrite it if
@@ -235,22 +233,39 @@ module Ruport
       # (print something out, write to file, email, etc)
       # 
       # Finally, it tries to call cleanup.
-      def run(*reports)
-        reports[0] ||= self.new
-        reports.each { |rep|
-          rep.prepare if rep.respond_to? :prepare;
-          rep.results = rep.generate;
-          yield(rep) if block_given?
-          rep.cleanup if rep.respond_to? :cleanup;
-        }
+      def run(options={})
+        options[:reports] ||= [self.new]
+
+        process = lambda do
+          options[:reports].each { |rep|
+            rep.prepare if rep.respond_to? :prepare
+            rep.results = rep.generate
+            yield(rep) if block_given?
+            rep.cleanup if rep.respond_to? :cleanup
+          }
+        end
+
+        if options[:tries] && (options[:interval] || options[:timeout])
+          code = Attempt.new { |a| 
+            a.tries = options[:tries]
+            a.interval = options[:interval] if options[:interval]
+            a.timeout = options[:timeout] if options[:timeout]
+            a.log_level = options[:log_level]
+          }
+          code.attempt(&process)
+        else
+          process.call
+        end
       end
+
     end
 
     # this method passes <tt>self</tt> to Report.run 
     #
     # Please see the class method for details.
-    def run(&block)
-      self.class.run(self,&block)
+    def run(options={},&block)
+      options[:reports] ||= [self]
+      self.class.run(options,&block)
     end
 
 
@@ -282,7 +297,7 @@ module Ruport
       m = Mailer.new
       m.to = adds
       yield(m)
-      m.select_mailer @mailer
+      m.send(:select_mailer,@mailer)
       m.deliver :from => m.from, :to => m.to
     end