ruport 1.6.3 → 1.7.1

data/examples/pdf_grouping.rb

@@ -0,0 +1,39 @@
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require "ruport"
+require "ruby-debug"
+
+class Document < Ruport::Controller
+  stage :title, :body
+
+  def setup
+    table = Ruport::Data::Table.load('data/wine.csv')
+    grouping = Grouping(table, :by => 'Type')
+    self.data = grouping
+  end
+end
+
+class DocumentFormatter < Ruport::Formatter::PrawnPDF
+  renders :prawn_pdf, :for => Document
+
+  def build_title
+    pad(10) do
+      text 'WINES', :style => :bold, :size => 20
+      horizontal_rule
+    end
+  end
+
+  def build_body
+    render_grouping(data, :formatter => pdf) # It's Nasty!!!
+  end
+end
+
+class DocumentTextFormatter < Ruport::Formatter::Text
+  renders :text, :for => Document
+
+  def build_body
+    output << data.to_text
+  end
+end
+
+Document.render(:prawn_pdf, :file => 'pdf_grouping.pdf')

data/examples/pdf_table.rb

@@ -0,0 +1,28 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require "ruport"
+
+# Example using prawn 0.9.0 pdf generator
+class Document < Ruport::Controller
+  stage :body
+
+  def setup
+    self.data = Ruport::Data::Table.new(
+      :column_names => %w(Make Model Year),
+      :data => [
+        %w(Nissan Skyline 1989),
+        %w(Mercedes-Benz 500SL 2005),
+        %w(Kia Sinatra 2008)
+       ])
+  end
+end
+
+class DocumentFormatter < Ruport::Formatter::PrawnPDF
+  renders :prawn_pdf, :for => Document
+
+  def build_body
+    draw_table(data)
+  end
+end
+
+Document.render(:prawn_pdf, :file => 'pdf_table.pdf')
+

data/examples/pdf_table_from_csv.rb

@@ -0,0 +1,26 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require "ruport"
+
+class Document < Ruport::Controller
+  stage :title, :body
+
+  def setup
+    self.data = Ruport::Data::Table.load('data/wine.csv')
+  end
+end
+
+class DocumentFormatter < Ruport::Formatter::PrawnPDF
+  renders :prawn_pdf, :for => Document
+
+  def build_title
+    pad(10) do
+      text 'Wine', :style => :bold, :size => 20
+    end
+  end
+
+  def build_body
+    draw_table(data)
+  end
+end
+
+Document.render(:prawn_pdf, :file => 'pdf_table_from_csv.pdf')

data/examples/pdf_table_prawn.rb

@@ -0,0 +1,30 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "ruport"
+
+table = Ruport::Data::Table.new(
+          :column_names => %w(Make Model Year Class),
+          :data => [
+            %w(Nissan Skyline 1989 B),
+            %w(Mercedes-Benz 500SL 2005 A),
+            %w(Kia Sinatra 2008 C)
+        ])
+
+pdf_options = { :pdf_format => {
+                  :page_layout => :portrait,
+                  :page_size => "LETTER",
+                  },
+                :table_format => {
+                  :cell_style => { :size => 8},
+                  :row_colors => ["FFFFFF","F0F0F0"], 
+                  :column_widths => {
+                    0 => 100,
+                    1 => 100,
+                    2 => 50,
+                    3 => 40
+                    }                    
+                  },
+                :file => 'pdf_table_prawn.pdf'
+                }
+
+table.to_prawn_pdf(pdf_options)

data/examples/pdf_table_simple.rb

@@ -0,0 +1,13 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require "ruport"
+
+# Quick and simple example using prawn 0.9.0 with to_prawn_pdf.
+table = Ruport::Data::Table.new(
+          :column_names => %w(Make Model Year),
+          :data => [
+            %w(Nissan Skyline 1989),
+            %w(Mercedes-Benz 500SL 2005),
+            %w(Kia Sinatra 2008)
+        ])
+
+table.to_prawn_pdf(:file => 'pdf_table_simple.pdf')

data/lib/ruport.rb

@@ -10,18 +10,6 @@
 # See LICENSE and COPYING for details
 #
  
-
-if RUBY_VERSION > "1.9"     
-  require "csv"   
-  unless defined? FCSV
-    class Object   
-      FCSV = CSV  
-      alias_method :FCSV, :CSV 
-    end   
-  end
-end
-
-
 module Ruport #:nodoc:#
   class FormatterError < RuntimeError #:nodoc:
   end

data/lib/ruport/controller.rb

@@ -165,19 +165,15 @@ class Ruport::Controller
     #  Example:
     #
     #    table.as(:csv, :show_table_headers => false)
-    def as(format,options={})
+    def as(format, options = {})
       raise ControllerNotSetError unless self.class.controller
-      unless self.class.controller.formats.include?(format)
-        raise UnknownFormatError
+      raise UnknownFormatError unless self.class.controller.formats.include?(format)
+      self.class.controller.render(format, self.class.rendering_options.merge(options)) do |rend|
+          rend.data = respond_to?(:renderable_data) ? renderable_data(format) : self
+          yield(rend) if block_given?
       end
-      self.class.controller.render(format,
-        self.class.rendering_options.merge(options)) do |rend|
-          rend.data =
-            respond_to?(:renderable_data) ? renderable_data(format) : self
-          yield(rend) if block_given?  
-      end
-    end      
-    
+    end
+
     def save_as(file,options={})
       file =~ /.*\.(.*)/    
       format = $1
@@ -221,6 +217,7 @@ class Ruport::Controller
      { :html => Ruport::Formatter::HTML,
        :csv  => Ruport::Formatter::CSV,
        :pdf  => Ruport::Formatter::PDF,
+       :prawn_pdf => Ruport::Formatter::PrawnPDF,
        :text => Ruport::Formatter::Text }
     end
 
@@ -389,16 +386,16 @@ class Ruport::Controller
     #      # other details omitted
     #   end
     def required_option(*opts) 
-      self.required_options ||= []
-      opts.each do |opt|
-        self.required_options << opt 
+      (self.required_options ||= []).concat(opts)
 
-        o = opt
-        unless instance_methods(false).include?(o.to_s)
-          define_method(o) { options.send(o.to_s) }
+      opts.each do |opt|
+        unless method_defined?(opt)
+          define_method(opt) { options.send(opt) }
+        end
+        setter = "#{opt}="
+        unless method_defined?(setter)
+          define_method(setter) {|t| options.send(setter, t) }
         end
-        opt = "#{opt}="
-        define_method(opt) {|t| options.send(opt, t) }
       end
     end
 
@@ -573,7 +570,6 @@ class Ruport::Controller
     else
       execute_stages
     end
-
     finalize self.class.final_stage if self.class.final_stage
     maybe :finalize
   end  

data/lib/ruport/data/feeder.rb

@@ -14,7 +14,7 @@
 #
 # Table Example:
 #
-#   t = Table(%w[a b c]) do |feeder|
+#   t = Ruport::Data::Table(%w[a b c]) do |feeder|
 #      feeder.filter { |r| r.a < 5 }
 #      feeder.transform { |r| r.b = "B: #{r.b}"}    
 #      feeder << [1,2,3]
@@ -108,4 +108,4 @@ class Ruport::Data::Feeder
     @constraints << [:transform,block]
   end
   
-end
+end

data/lib/ruport/data/grouping.rb

@@ -285,7 +285,7 @@ module Ruport::Data
       else 
         cols = procs.keys + [field]   
       end
-      expected = Table(cols) { |t|
+      expected = Table.new(:column_names => cols) { |t|
         each do |name,group|
           t << procs.inject({field => name}) do |s,r|
             s.merge(r[0] => r[1].call(group))
@@ -379,7 +379,7 @@ module Kernel
   #
   # Example:
   #
-  #   a = Table(%w[a b c], :data => [[1,2,3],[4,5,6]])
+  #   a = Ruport::Data::Table.new(%w[a b c], :data => [[1,2,3],[4,5,6]])
   #   b = Grouping(a, :by => "a")   #=> creates a new grouping on column "a"
   #
   def Grouping(*args)

data/lib/ruport/data/table.rb

@@ -1,21 +1,24 @@
 # Ruport : Extensible Reporting System
 #
 # data/table.rb provides a table data structure for Ruport.
-# 
+#
 # Created by Gregory Brown / Dudley Flanders, 2006
-# Copyright (C) 2006 Gregory Brown / Dudley Flanders, All Rights Reserved.  
+# Copyright (C) 2006 Gregory Brown / Dudley Flanders, All Rights Reserved.
 #
 # This is free software distributed under the same terms as Ruby 1.8
-# See LICENSE and COPYING for details.   
+# See LICENSE and COPYING for details.
 #
+
+require "csv"
+
 module Ruport::Data
- 
+
   # === Overview
   #
-  # This class is one of the core classes for building and working with data 
-  # in Ruport. The idea is to get your data into a standard form, regardless 
+  # This class is one of the core classes for building and working with data
+  # in Ruport. The idea is to get your data into a standard form, regardless
   # of its source (a database, manual arrays, ActiveRecord, CSVs, etc.).
-  # 
+  #
   # Table is intended to be used as the data store for structured, tabular
   # data.
   #
@@ -32,9 +35,57 @@ module Ruport::Data
         @pivot_column = pivot_col
         @summary_column = summary_col
         @pivot_order = options[:pivot_order]
+        @operation = options[:operation] || :first
+        unless Operations.respond_to?(@operation, true)
+          raise ArgumentError, "Unknown pivot operation '#{@operation}'"
+        end
+      end
+
+      # Row is the first row in the pivoted table (without the group column)
+      def row
+        return @row if defined?(@row)
+
+        pivot_column_grouping = Grouping(@table, :by => @pivot_column)
+
+        ordering = self.class.row_order_to_group_order(@pivot_order)
+        pivot_column_grouping.sort_grouping_by!(ordering) if ordering
+
+        @row = pivot_column_grouping.map { |name,grouping| name }
+      end
+
+      # Column in the first column in the pivoted table (without the group column)
+      def column
+        @column ||= @table.map { |row| row[@group_column] }.uniq
+      end
+
+      def to_table
+        table = Table.new
+        create_header(table)
+
+        column.each do |column_entry|
+          row_values = row.map { |row_entry| values[column_entry][row_entry] }
+          table << [column_entry] + row_values
+        end
+
+        table
+      end
+
+      def values
+        @values ||= Hash.new do |values, column_entry|
+          rows_group = rows_groups[column_entry]
+
+          values[column_entry] =
+            row.inject({}) do |values, row_entry|
+              matching_rows = rows_group.rows_with(@pivot_column => row_entry)
+              values[row_entry] = perform_operation(matching_rows)
+              values
+            end
+        end
       end
 
-      def convert_row_order_to_group_order(row_order_spec)
+      private
+
+      def self.row_order_to_group_order(row_order_spec)
         case row_order_spec
         when Array
           proc {|group|
@@ -50,45 +101,55 @@ module Ruport::Data
           }
         when NilClass
           nil
+        when :name  # Pass through :name as it's a special instruction to Grouping
+          :name
         else
           proc {|group| group[0][row_order_spec].to_s }
         end
       end
 
-      def columns_from_pivot
-        ordering = convert_row_order_to_group_order(@pivot_order)
-        pivot_column_grouping = Grouping(@table, :by => @pivot_column)
-        pivot_column_grouping.each {|n,g| g.add_column(n) { n }}
-        pivot_column_grouping.sort_grouping_by!(ordering) if ordering
-        result = []
-        pivot_column_grouping.each {|name,_| result << name }
-        result
+      def create_header(table)
+        table.add_column(@group_column)
+        row.each { |name| table.add_column(name) }
       end
 
-      def group_column_entries
-        @table.map {|row| row[@group_column]}.uniq
+      def perform_operation(rows)
+        Operations.send @operation, rows, @summary_column
       end
 
-      def to_table
-        result = Table()
-        result.add_column(@group_column)
-        pivoted_columns = columns_from_pivot
-        pivoted_columns.each { |name| result.add_column(name) }
-        outer_grouping = Grouping(@table, :by => @group_column)
-        group_column_entries.each {|outer_group_name|
-          outer_group = outer_grouping[outer_group_name]
-          pivot_values = pivoted_columns.inject({}) do |hsh, e|
-            matching_rows = outer_group.rows_with(@pivot_column => e)
-            hsh[e] = matching_rows.first && matching_rows.first[@summary_column]
-            hsh
-          end
-          result << [outer_group_name] + pivoted_columns.map {|e| 
-            pivot_values[e]
-          }
-        }
-        result
+      def rows_groups
+        @rows_groups ||= Grouping(@table, :by => @group_column)
       end
 
+      module Operations
+        extend self
+
+        def first(rows, summary_column)
+          rows.first && rows.first[summary_column]
+        end
+
+        def sum(rows, summary_column)
+          rows && rows.inject(0) { |sum,row| sum+row[summary_column] }
+        end
+
+        def count(rows, summary_column)
+          rows && rows.length
+        end
+
+        def mean(rows, summary_column)
+          return if rows.length == 0
+          sum = rows && rows.inject(0) { |sum,row| sum+row[summary_column] }
+          sum / rows.length
+        end
+
+        def min(rows, summary_column)
+          rows && (rows.collect { |r| r[summary_column] }).min
+        end
+
+        def max(rows, summary_column)
+          rows && (rows.collect { |r| r[summary_column] }).max
+        end
+      end
     end
 
     # Creates a new table with values from the specified pivot column
@@ -113,6 +174,14 @@ module Ruport::Data
     #                                   first argument. This wart will likely
     #                                   be fixed in a future version.
     #
+    # <b><tt>:operation</tt></b>::      The operation to perform on
+    #                                   <tt>:values</tt> column. Supported
+    #                                   operations are <tt>:first</tt>,
+    #                                   <tt>:sum</tt>, <tt>:count</tt>,
+    #                                   <tt>:mean</tt>, <tt>:min</tt>, and
+    #                                   <tt>:max</tt>. If not specified, the
+    #                                   default is <tt>:first</tt>.
+    #
     # Example:
     #
     # Given a table <em>my_table</em>:
@@ -139,9 +208,9 @@ module Ruport::Data
     #    +---------------+
     #
     def pivot(pivot_column, options = {})
-      group_column = options[:group_by] || 
+      group_column = options[:group_by] ||
         raise(ArgumentError, ":group_by option required")
-      value_column = options[:values]   || 
+      value_column = options[:values]   ||
         raise(ArgumentError, ":values option required")
       Pivot.new(
         self, group_column, pivot_column, value_column, options
@@ -153,10 +222,10 @@ module Ruport::Data
     # This module provides facilities for creating tables from csv data.
     #
     module FromCSV
-      # Loads a CSV file directly into a Table using the FasterCSV library.
+      # Loads a CSV file directly into a Table.
       #
       # Example:
-      #   
+      #
       #   # treat first row as column_names
       #   table = Table.load('mydata.csv')
       #
@@ -169,8 +238,8 @@ module Ruport::Data
       def load(csv_file, options={},&block)
         get_table_from_csv(:foreach, csv_file, options,&block)
       end
-      
-      # Creates a Table from a CSV string using FasterCSV.  See Table.load for
+
+      # Creates a Table from a CSV string.  See Table.load for
       # additional examples.
       #
       #   table = Table.parse("a,b,c\n1,2,3\n4,5,6\n")
@@ -180,32 +249,31 @@ module Ruport::Data
       end
 
       private
-      
-      def get_table_from_csv(msg,param,options={},&block) #:nodoc:
-        require "fastercsv"
 
+      def get_table_from_csv(msg,param,options={},&block) #:nodoc:
         options = {:has_names => true,
                    :csv_options => {} }.merge(options)
-              
+
         adjust_options_for_fcsv_headers(options)
 
         table = self.new(options) do |feeder|
           first_line = true
-          FasterCSV.send(msg,param,options[:csv_options]) do |row|
+
+          ::CSV.send(msg,param,options[:csv_options]) do |row|
             if first_line
               adjust_for_headers(feeder.data,row,options)
               first_line = false
               next if options[:has_names]
             end
-               
+
             if block
               handle_csv_row_proc(feeder,row,options,block)
             else
               feeder << row
-            end  
+            end
           end
         end
-        
+
         return table
       end
 
@@ -214,10 +282,10 @@ module Ruport::Data
           rc = options[:record_class] || Record
           row = rc.new(row, :attributes => feeder.data.column_names)
         end
-        
+
         block[feeder,row]
       end
-       
+
       def adjust_options_for_fcsv_headers(options)
         options[:has_names] = false if options[:csv_options][:headers]
       end
@@ -231,7 +299,7 @@ module Ruport::Data
       end
     end
 
-    include Enumerable             
+    include Enumerable
     extend FromCSV
 
     include Ruport::Controller::Hooks
@@ -240,13 +308,13 @@ module Ruport::Data
     def self.inherited(base) #:nodoc:
       base.renders_as_table
     end
-    
+
     # Creates a new table based on the supplied options.
     #
     # Valid options:
-    # <b><tt>:data</tt></b>::           An Array of Arrays representing the 
+    # <b><tt>:data</tt></b>::           An Array of Arrays representing the
     #                                   records in this Table.
-    # <b><tt>:column_names</tt></b>::   An Array containing the column names 
+    # <b><tt>:column_names</tt></b>::   An Array containing the column names
     #                                   for this Table.
     # <b><tt>:filters</tt></b>::        A proc or array of procs that set up
     #                                   conditions to filter the data being
@@ -259,55 +327,55 @@ module Ruport::Data
     #
     # Example:
     #
-    #   table = Table.new :data => [[1,2,3], [3,4,5]], 
+    #   table = Table.new :data => [[1,2,3], [3,4,5]],
     #                     :column_names => %w[a b c]
     #
     def initialize(options={})
       @column_names = options[:column_names] ? options[:column_names].dup : []
       @record_class = options[:record_class] &&
                       options[:record_class].name || "Ruport::Data::Record"
-      @data         = []  
-      
+      @data         = []
+
       feeder = Feeder.new(self)
-     
+
       Array(options[:filters]).each { |f| feeder.filter(&f) }
       Array(options[:transforms]).each { |t| feeder.transform(&t) }
-      
+
       if options[:data]
         options[:data].each do |e|
           if e.kind_of?(Record)
-            e = if @column_names.empty? or 
+            e = if @column_names.empty? or
                    e.attributes.all? { |a| a.kind_of?(Numeric) }
               e.to_a
             else
-              e.to_hash.values_at(*@column_names)  
+              e.to_hash.values_at(*@column_names)
             end
           end
           r = recordize(e)
-                                                     
+
           feeder << r
-        end  
-      end    
-      
-      yield(feeder) if block_given?  
+        end
+      end
+
+      yield(feeder) if block_given?
     end
 
     # This Table's column names
     attr_reader :column_names
-    
+
     # This Table's data
-    attr_reader :data        
-    
+    attr_reader :data
+
     require "forwardable"
     extend Forwardable
     def_delegators :@data, :each, :length, :size, :empty?, :[]
-    
-    # Sets the column names for this table. <tt>new_column_names</tt> should 
+
+    # Sets the column names for this table. <tt>new_column_names</tt> should
     # be an array listing the names of the columns.
     #
     # Example:
-    #                     
-    #   table = Table.new :data => [[1,2,3], [3,4,5]], 
+    #
+    #   table = Table.new :data => [[1,2,3], [3,4,5]],
     #                     :column_names => %w[a b c]
     #
     #   table.column_names = %w[e f g]
@@ -334,27 +402,27 @@ module Ruport::Data
     #
     # Example:
     #
-    #   one = Table.new :data => [[1,2], [3,4]], 
+    #   one = Table.new :data => [[1,2], [3,4]],
     #                   :column_names => %w[a b]
     #
-    #   two = Table.new :data => [[1,2], [3,4]], 
+    #   two = Table.new :data => [[1,2], [3,4]],
     #                   :column_names => %w[a b]
     #
     #   one.eql?(two) #=> true
     #
     def eql?(other)
-      data.eql?(other.data) && column_names.eql?(other.column_names) 
+      data.eql?(other.data) && column_names.eql?(other.column_names)
     end
 
     alias_method :==, :eql?
 
-    # Used to add extra data to the Table. <tt>row</tt> can be an Array, 
+    # Used to add extra data to the Table. <tt>row</tt> can be an Array,
     # Hash or Record. It also can be anything that implements a meaningful
     # to_hash or to_ary.
     #
     # Example:
     #
-    #   data = Table.new :data => [[1,2], [3,4]], 
+    #   data = Table.new :data => [[1,2], [3,4]],
     #                    :column_names => %w[a b]
     #   data << [8,9]
     #   data << { :a => 4, :b => 5}
@@ -362,23 +430,33 @@ module Ruport::Data
     #
     def <<(row)
       @data << recordize(row)
-      return self   
-    end    
-    
+      return self
+    end
+
+    # Add a row to a certain location within the existing table.
+    #
+    # data.add_row([8,9], :position => 0)
+    #
+    #
+    def add_row(row_data, options={})
+      @data.insert(options[:position] || @data.length, recordize(row_data))
+      return self
+    end
+
     # Returns the record class constant being used by the table.
     def record_class
       @record_class.split("::").inject(Class) { |c,el| c.send(:const_get,el) }
     end
-    
+
     # Used to merge two Tables by rows.
     # Raises an ArgumentError if the Tables don't have identical columns.
     #
     # Example:
     #
-    #   inky = Table.new :data => [[1,2], [3,4]], 
+    #   inky = Table.new :data => [[1,2], [3,4]],
     #                    :column_names => %w[a b]
     #
-    #   blinky = Table.new :data => [[5,6]], 
+    #   blinky = Table.new :data => [[5,6]],
     #                      :column_names => %w[a b]
     #
     #   sue = inky + blinky
@@ -386,11 +464,11 @@ module Ruport::Data
     #
     def +(other)
       raise ArgumentError unless other.column_names == @column_names
-      self.class.new( :column_names => @column_names, 
+      self.class.new( :column_names => @column_names,
                       :data => @data + other.data,
                       :record_class => record_class )
     end
-  
+
     # Allows you to change the order of, or reduce the number of columns in a
     # Table.
     #
@@ -411,40 +489,40 @@ module Ruport::Data
     def reorder(*indices)
       raise(ArgumentError,"Can't reorder without column names set!") if
         @column_names.empty?
-      
+
       indices = indices[0] if indices[0].kind_of? Array
-      
-      if indices.all? { |i| i.kind_of? Integer }  
-        indices.map! { |i| @column_names[i] }  
+
+      if indices.all? { |i| i.kind_of? Integer }
+        indices.map! { |i| @column_names[i] }
       end
-      
+
       reduce(indices)
     end
-    
+
     # Adds an extra column to the Table.
     #
     # Available Options:
-    # <b><tt>:default</tt></b>:: The default value to use for the column in 
+    # <b><tt>:default</tt></b>:: The default value to use for the column in
     #                            existing rows. Set to nil if not specified.
-    # 
+    #
     # <b><tt>:position</tt></b>:: Inserts the column at the indicated position
     #                             number.
     #
-    # <b><tt>:before</tt></b>:: Inserts the new column before the column 
+    # <b><tt>:before</tt></b>:: Inserts the new column before the column
     #                           indicated (by name).
     #
     # <b><tt>:after</tt></b>:: Inserts the new column after the column
     #                          indicated (by name).
     #
     # If a block is provided, it will be used to build up the column.
-    #   
+    #
     # Example:
     #
-    #   data = Table("a","b") { |t| t << [1,2] << [3,4] }
-    #   
+    #   data = Table.new("a","b") { |t| t << [1,2] << [3,4] }
+    #
     #   # basic usage, column full of 1's
     #   data.add_column 'new_column', :default => 1
-    #        
+    #
     #   # new empty column before new_column
     #   data.add_column 'new_col2', :before => 'new_column'
     #
@@ -453,43 +531,43 @@ module Ruport::Data
     #
     #   # new column built via a block, added at the end of the table
     #   data.add_column("new_col4") { |r| r.a + r.b }
-    #   
+    #
     def add_column(name,options={})
       if pos = options[:position]
-        column_names.insert(pos,name)   
+        column_names.insert(pos,name)
       elsif pos = options[:after]
-        column_names.insert(column_names.index(pos)+1,name)   
+        column_names.insert(column_names.index(pos)+1,name)
       elsif pos = options[:before]
         column_names.insert(column_names.index(pos),name)
       else
         column_names << name
-      end 
+      end
 
       if block_given?
         each { |r| r[name] = yield(r) || options[:default] }
       else
         each { |r| r[name] = options[:default] }
       end; self
-    end     
-    
+    end
+
     # Add multiple extra columns to the Table. See <tt>add_column</tt> for
     # a list of available options.
-    #   
+    #
     # Example:
     #
-    #   data = Table("a","b") { |t| t << [1,2] << [3,4] }
-    #   
+    #   data = Table.new("a","b") { |t| t << [1,2] << [3,4] }
+    #
     #   data.add_columns ['new_column_1','new_column_2'], :default => 1
     #
-    def add_columns(names,options={})     
+    def add_columns(names,options={})
       raise "Greg isn't smart enough to figure this out.\n"+
             "Send ideas in at http://list.rubyreports.org" if block_given?
       need_reverse = !!(options[:after] || options[:position])
       names = names.reverse if need_reverse
-      names.each { |n| add_column(n,options) } 
+      names.each { |n| add_column(n,options) }
       self
     end
-    
+
     # Removes the given column from the table.  May use name or position.
     #
     # Example:
@@ -502,7 +580,7 @@ module Ruport::Data
       column_names.delete(col)
       each { |r| r.send(:delete,col) }
     end
-   
+
     # Removes multiple columns from the table.  May use name or position
     # Will autosplat arrays.
     #
@@ -514,9 +592,9 @@ module Ruport::Data
       cols = cols[0] if cols[0].kind_of? Array
       cols.each { |col| remove_column(col) }
     end
-    
+
     # Renames a column.  Will update Record attributes as well.
-    # 
+    #
     # Example:
     #
     #   old_values = table.map { |r| r.a }
@@ -528,12 +606,12 @@ module Ruport::Data
     def rename_column(old_name,new_name)
       index = column_names.index(old_name) or return
       self.column_names[index] = new_name
-      each { |r| r.rename_attribute(old_name,new_name,false)} 
+      each { |r| r.rename_attribute(old_name,new_name,false)}
     end
 
     # Renames multiple columns.  Takes either a hash of "old" => "new"
     # names or two arrays of names %w[old names],%w[new names].
-    # 
+    #
     # Example:
     #
     #   table.column_names #=> ["a", "b"]
@@ -553,7 +631,7 @@ module Ruport::Data
         end
         return
       end
-      
+
       raise ArgumentError unless old_cols
 
       if new_cols
@@ -565,12 +643,12 @@ module Ruport::Data
       end
       h.each {|old,new| rename_column(old,new) }
     end
-    
+
     #  Exchanges one column with another.
     #
-    #  Example: 
+    #  Example:
     #
-    #    >> a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] } 
+    #    >> a = Table.new(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     #    >> puts a
     #       +-----------+
     #       | a | b | c |
@@ -587,24 +665,24 @@ module Ruport::Data
     #       | 6 | 5 | 4 |
     #       +-----------+
     #
-    def swap_column(a,b)    
+    def swap_column(a,b)
       if [a,b].all? { |r| r.kind_of? Fixnum }
        col_a,col_b = column_names[a],column_names[b]
        column_names[a] = col_b
        column_names[b] = col_a
       else
-        a_ind, b_ind = [column_names.index(a), column_names.index(b)] 
+        a_ind, b_ind = [column_names.index(a), column_names.index(b)]
         column_names[b_ind] = a
         column_names[a_ind] = b
       end
     end
-       
+
     #  Allows you to specify a new column to replace an existing column
     #  in your table via a block.
     #
     #  Example:
     #
-    #  >> a = Table(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
+    #  >> a = Table.new(%w[a b c]) { |t| t << [1,2,3] << [4,5,6] }
     #  >> a.replace_column("c","c2") { |r| r.c * 2 + r.a }
     #
     #  >> puts a
@@ -622,12 +700,12 @@ module Ruport::Data
       else
         each { |r| r[old_col] = yield(r) }
       end
-    end         
-          
+    end
+
     #  Generates a sub table
-    #  
+    #
     #  Examples:
-    #   
+    #
     #    table = [[1,2,3,4],[5,6,7,8],[9,10,11,12]].to_table(%w[a b c d])
     #
     #  Using column_names and a range:
@@ -641,16 +719,16 @@ module Ruport::Data
     #     sub_table == [[1,4],[5,8],[9,12]].to_table(%w[a d]) #=> true
     #
     #  Using column_names and a block:
-    # 
-    #     sub_table = table.sub_table(%w[d b]) { |r| r.a < 6 } 
-    #     sub_table == [[4,2],[8,6]].to_table(%w[d b]) #=> true 
+    #
+    #     sub_table = table.sub_table(%w[d b]) { |r| r.a < 6 }
+    #     sub_table == [[4,2],[8,6]].to_table(%w[d b]) #=> true
     #
     #  Using a range for row reduction:
     #     sub_table = table.sub_table(1..-1)
     #     sub_table == [[5,6,7,8],[9,10,11,12]].to_table(%w[a b c d]) #=> true
     #
     #  Using just a block:
-    #      
+    #
     #     sub_table = table.sub_table { |r| r.c > 10 }
     #     sub_table == [[9,10,11,12]].to_table(%w[a b c d]) #=> true
     #
@@ -662,8 +740,8 @@ module Ruport::Data
       elsif block
         self.class.new( :column_names => cor, :data => data.select(&block))
       else
-        self.class.new( :column_names => cor, :data => data)  
-      end 
+        self.class.new( :column_names => cor, :data => data)
+      end
     end
 
     # Generates a sub table in place, modifying the receiver. See documentation
@@ -677,7 +755,7 @@ module Ruport::Data
     end
 
     alias_method :sub_table!, :reduce
-    
+
     # Returns an array of values for the given column name.
     #
     # Example:
@@ -689,20 +767,20 @@ module Ruport::Data
       case(name)
       when Integer
         unless column_names.empty?
-          raise ArgumentError if name > column_names.length         
+          raise ArgumentError if name > column_names.length
         end
       else
         raise ArgumentError unless column_names.include?(name)
       end
-         
+
       map { |r| r[name] }
     end
-    
+
     # Calculates sums. If a column name or index is given, it will try to
-    # convert each element of that column to an integer or float 
+    # convert each element of that column to an integer or float
     # and add them together.
     #
-    # If a block is given, it yields each Record so that you can do your own 
+    # If a block is given, it yields each Record so that you can do your own
     # calculation.
     #
     # Example:
@@ -714,7 +792,7 @@ module Ruport::Data
     #   table.sigma { |r| r.col2 + 1 } #=> 15
     #
     def sigma(column=nil)
-      inject(0) { |s,r| 
+      inject(0) { |s,r|
         if column
           s + if r.get(column).kind_of? Numeric
             r.get(column)
@@ -724,12 +802,12 @@ module Ruport::Data
         else
           s + yield(r)
         end
-      }      
+      }
     end
 
     alias_method :sum, :sigma
 
-    # Returns a sorted table. If col_names is specified, 
+    # Returns a sorted table. If col_names is specified,
     # the block is ignored and the table is sorted by the named columns.
     #
     # The second argument specifies sorting options. Currently only
@@ -759,54 +837,54 @@ module Ruport::Data
     #   table.sort_rows_by(["col1", "col2"], :order => descending)
     #
     def sort_rows_by(col_names=nil, options={}, &block)
-      # stabilizer is needed because of 
+      # stabilizer is needed because of
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/170565
       stabilizer = 0
-      
-      nil_rows, sortable = partition do |r| 
-        Array(col_names).any? { |c| r[c].nil? } 
+
+      nil_rows, sortable = partition do |r|
+        Array(col_names).any? { |c| r[c].nil? }
       end
 
       data_array =
         if col_names
-          sortable.sort_by do |r| 
+          sortable.sort_by do |r|
             stabilizer += 1
-            [Array(col_names).map {|col| r[col]}, stabilizer] 
+            [Array(col_names).map {|col| r[col]}, stabilizer]
           end
         else
           sortable.sort_by(&block)
-        end                 
-                                                               
+        end
+
       data_array += nil_rows
-      data_array.reverse! if options[:order] == :descending    
+      data_array.reverse! if options[:order] == :descending
 
-      table = self.class.new( :data => data_array, 
+      table = self.class.new( :data => data_array,
                               :column_names => @column_names,
                               :record_class => record_class )
 
       return table
-    end   
-    
+    end
+
     # Same as Table#sort_rows_by, but self modifying.
     # See <tt>sort_rows_by</tt> for documentation.
     #
     def sort_rows_by!(col_names=nil,options={},&block)
-      table = sort_rows_by(col_names,options,&block) 
+      table = sort_rows_by(col_names,options,&block)
       @data = table.data
     end
-    
+
     # Get an array of records from the Table limited by the criteria specified.
     #
     # Example:
     #
-    #   table = Table.new :data => [[1,2,3], [1,4,6], [4,5,6]], 
+    #   table = Table.new :data => [[1,2,3], [1,4,6], [4,5,6]],
     #                     :column_names => %w[a b c]
     #   table.rows_with(:a => 1)           #=> [[1,2,3], [1,4,6]]
     #   table.rows_with(:a => 1, :b => 4)  #=> [[1,4,6]]
     #   table.rows_with_a(1)               #=> [[1,2,3], [1,4,6]]
     #   table.rows_with(%w[a b]) {|a,b| [a,b] == [1,4] }  #=> [[1,4,6]]
     #
-    def rows_with(columns,&block) 
+    def rows_with(columns,&block)
       select { |r|
         if block
           block[*(columns.map { |c| r.get(c) })]
@@ -816,11 +894,48 @@ module Ruport::Data
       }
     end
 
+    # Search row for a string and return the position
+    #
+    # Example:
+    #
+    #   table = Table.new :data => [["Mow Lawn","50"], ["Sew","40"], ["Clean dishes","5"]],
+    #                     :column_names => %w[task cost]
+    #   table.row_search("Sew", :column => 0)           #=> [[1,2,3], [1,4,6]]
+    #
+    #   Search for a number in column 0 greater than 999.
+    #   result = table.row_search(999, :column => 0, :greater_than => true)
+    #
+    #
+    def row_search(search, options={})
+      position = 0
+
+      if column = options[:column]
+        self.each do |row|
+
+          if gt=options[:greater_than]
+            return position if row[column] > search
+          end
+
+          if lt=options[:less_than]
+            return position if row[column] < search
+          end
+
+          unless gt or lt
+            if row[column] =~ /#{search}/       # Search for part of or whole search text.
+              return position
+            end
+          end
+
+          position += 1
+        end
+      end
+    end
+
     # Create a copy of the Table. Records will be copied as well.
     #
     # Example:
     #
-    #   one = Table.new :data => [[1,2], [3,4]], 
+    #   one = Table.new :data => [[1,2], [3,4]],
     #                   :column_names => %w[a b]
     #   two = one.dup
     #
@@ -830,32 +945,32 @@ module Ruport::Data
       @data = []
       from.data.each { |r| self << r.dup }
     end
-    
+
     # Uses Ruport's built-in text formatter to render this Table into a String.
-    # 
+    #
     # Example:
-    # 
-    #   data = Table.new :data => [[1,2], [3,4]], 
+    #
+    #   data = Table.new :data => [[1,2], [3,4]],
     #                    :column_names => %w[a b]
     #   puts data.to_s
-    # 
+    #
     def to_s
       as(:text)
-    end     
+    end
 
     # Convert the Table into a Group using the supplied group name.
     #
-    #   data = Table.new :data => [[1,2], [3,4]], 
+    #   data = Table.new :data => [[1,2], [3,4]],
     #                    :column_names => %w[a b]
     #   group = data.to_group("my_group")
     #
     def to_group(name=nil)
-      Group.new( :data => data, 
+      Group.new( :data => data,
                  :column_names => column_names,
                  :name => name,
                  :record_class => record_class )
     end
-                            
+
     # NOTE: does not respect tainted status
     alias_method :clone, :dup
 
@@ -866,50 +981,50 @@ module Ruport::Data
     # <tt>rows_with(:columnname => args[0])</tt>.
     #
     def method_missing(id,*args,&block)
-     return as($1.to_sym,*args,&block) if id.to_s =~ /^to_(.*)/ 
+     return as($1.to_sym,*args,&block) if id.to_s =~ /^to_(.*)/
      return rows_with($1.to_sym => args[0]) if id.to_s =~ /^rows_with_(.*)/
      super
     end
-    
+
     def feed_element(row)
        recordize(row)
     end
-    
-    private    
-    
+
+    private
+
     def recordize(row)
       case row
       when Array
         normalize_array(row)
       when Hash
-        normalize_hash(row)            
-      when record_class     
+        normalize_hash(row)
+      when record_class
         recordize(normalize_record(row))
       else
         normalize_hash(row) rescue normalize_array(row)
-      end    
-    end  
-    
+      end
+    end
+
     def normalize_hash(hash_obj)
-      hash_obj = hash_obj.to_hash 
+      hash_obj = hash_obj.to_hash
       raise ArgumentError unless @column_names
       record_class.new(hash_obj, :attributes => @column_names)
-    end 
-    
+    end
+
     def normalize_record(record)
       record.send(column_names.empty? ? :to_a : :to_hash)
-    end  
-    
+    end
+
     def normalize_array(array)
-      attributes = @column_names.empty? ? nil : @column_names 
-      record_class.new(array.to_ary, :attributes => attributes)                             
-    end                                            
+      attributes = @column_names.empty? ? nil : @column_names
+      record_class.new(array.to_ary, :attributes => attributes)
+    end
   end
 end
 
 
-module Kernel
-  
+module Ruport
+
   # Shortcut interface for creating Data::Tables
   #
   # Examples:
@@ -918,33 +1033,30 @@ module Kernel
   #   t = Table("a","b","c") #=> creates a new empty table w. cols a,b,c
   #
   #   # allows building table inside of block, returns table object
-  #   t = Table(%w[a b c]) { |t| t << [1,2,3] } 
+  #   t = Table(%w[a b c]) { |t| t << [1,2,3] }
   #
   #   # allows loading table from CSV
   #   # accepts all Data::Table.load options, including block (yields table,row)
   #
   #   t = Table("foo.csv")
   #   t = Table("bar.csv", :has_names => false)
-  def Table(*args,&block)
-    table=
+  def self.Table(*args,&block)
     case(args[0])
     when Array
       opts = args[1] || {}
       Ruport::Data::Table.new(f={:column_names => args[0]}.merge(opts),&block)
     when /\.csv/
-      return Ruport::Data::Table.load(*args,&block)
+      Ruport::Data::Table.load(*args,&block)
     when Hash
       if file = args[0].delete(:file)
-        return Ruport::Data::Table.load(file,args[0],&block)
+        Ruport::Data::Table.load(file,args[0],&block)
       elsif string = args[0].delete(:string)
-        return Ruport::Data::Table.parse(string,args[0],&block)
+        Ruport::Data::Table.parse(string,args[0],&block)
       else
-        return Ruport::Data::Table.new(args[0],&block)
+        Ruport::Data::Table.new(args[0],&block)
       end
     else
        Ruport::Data::Table.new(:data => [], :column_names => args,&block)
-    end             
-    
-    return table
+    end
   end
-end  
+end