ruport 1.0.2 → 1.2.0

data/AUTHORS

@@ -43,3 +43,6 @@ Stefan Mahlitz:
 
 Chris Carter
  - Table#remove_columns (r440)
+
+Dave Nelson
+ - Grouping#sigma (r1131)

data/README

@@ -1,4 +1,4 @@
-# ------------------------------------------------------------------------
+# -----------------------------------------------------------------
 # Contents:
 # 
 #  + What Ruport Is
@@ -27,6 +27,11 @@
 # functions that will let you build complex reports while maintaining a DRY and
 # consistent interface.
 #
+# To get a quick feel for what you can accomplish with Ruport, take a look at
+# a few simple examples provided on our web site.
+#
+# http://rubyreports.org/examples.html
+#
 # Since Ruport's core support is intentionally minimalistic, you may be looking
 # for some higher level support for specific needs such as graphing, invoices,
 # report mailing support, etc.  For this, you may wish to take a look at the
@@ -50,12 +55,13 @@
 #  -- formatting
 #
 # Ruport relies on PDF::Writer and FasterCSV for its formatting support.
-# If you want to make use of textile helpers, you'll also need RedCloth
+# If you want to make use of textile helpers, you'll also need RedCloth.
 #
 #  -- database interaction
 #
 # If you wish to use Ruport to report against a rails project, 
-# a camping project, or do standalone AAR reports, you'll need ActiveRecord.
+# a camping project, or do standalone acts_as_reportable reports, you'll need
+# ActiveRecord.
 #
 # If you want to use Ruport::Query for raw SQL support, you'll need to 
 # install RubyDBI and whatever database drivers you might need.
@@ -72,8 +78,8 @@
 #  -  The latest stable API documentation is available at:
 #     http://api.rubyreports.org
 #
-#  -  Our Trac is at: http://code.stonecode.org
-#     You may use the username ruport and password blinky to file tickets
+#  -  Our Trac is at: http://code.rubyreports.org/ruport
+#     You may use the username ruport and password blinky to file tickets.
 #
 # = Hacking
 #

data/Rakefile

@@ -1,9 +1,9 @@
 require "rake/rdoctask"
 require "rake/testtask"
 require "rake/gempackagetask"
+#
 
-
-RUPORT_VERSION = "1.0.2"
+RUPORT_VERSION = "1.2.0"
 
 begin
   require "rubygems"

data/examples/btree/commaleon/commaleon.rb

@@ -62,7 +62,7 @@ module Commaleon::Helpers
      option :key, :mcsv, :ccsv  
       
      # This setup() idiom has become the default way of doing some 
-     # manipulations on the data and optionsbefore handing off the 
+     # manipulations on the data and options before handing off the 
      # rendering task to the formatters.
      #   
      # We're using grouping mainly for the renderer support,

data/examples/simple_templating_example.rb

@@ -0,0 +1,34 @@
+require "ruport"
+
+Ruport::Formatter::Template.create(:simple) do |t|
+  t.page_format = {
+    :size   => "LETTER",
+    :layout => :landscape
+  }
+  t.text_format = {
+    :font_size => 16
+  }
+  t.table_format = {
+    :font_size      => 16,
+    :show_headings  => false
+  }
+  t.column_format = {
+    :alignment => :center,
+  }                       
+  t.heading_format = {
+    :alignment => :right
+  }
+  t.grouping_format = {
+    :style => :separated
+  }
+end
+
+Ruport::Formatter::Template.create(:derived, :base => :simple) do |t|
+  t.table_format[:show_headings] = true
+end
+
+t = Table(%w[a b c]) << [1,2,3] << [1,"hello",6] << [2,3,4] 
+g = Grouping(t, :by => "a")
+
+puts g.to_pdf(:template => :simple)
+#puts g.to_pdf(:template => :derived)

data/examples/tattle_rubygems_version.rb

@@ -1,8 +1,10 @@
 # A dump of the database for this example can be found in ./data/tattle.dump
 
+
 require "active_record"
 require "ruport"
 
+
 # Update with your connection parameters
 ActiveRecord::Base.establish_connection(
     :adapter  => 'mysql',
@@ -31,9 +33,8 @@ grouping.each do |name,group|
   end
 end
 
-sorted_table = rubygems_versions.sort_rows_by { |r| -r.count }
-g = Grouping(sorted_table, :by => "platform")
+sorted_table = rubygems_versions.sort_rows_by("count", :order => :descending)
+sorted_table.reduce { |r| r["platform"] !~ /darwin/i }
+g = Grouping(sorted_table, :by => "platform", :order => "name")
+puts g.to_pdf 
 
-File.open("platforms_gems.html", "w") do |f|
-  f.write g.to_html(:style => :justified)
-end

data/examples/trac_ticket_status.rb

@@ -41,7 +41,7 @@ class TracSummaryReport
     Grouping(table,:by => :date)
   end
 
-  def renderable_data
+  def renderable_data(format)
     summary = feed_data.summary :date,
       :opened => lambda { |g| g.sigma { |r| r.opened  } },
       :closed => lambda { |g| g.sigma { |r| r.closed  } },
@@ -54,6 +54,6 @@ end
 
 timeline = "http://stonecode.svnrepository.com/ruport/trac.cgi/timeline"
 
-report = TracSummaryReport.new(:timeline_uri => timeline, :days => 14)  
+report = TracSummaryReport.new(:timeline_uri => timeline, :days => 30)  
 puts report.as(:text)
 

data/lib/ruport.rb

@@ -12,7 +12,7 @@
 
 module Ruport #:nodoc:#
   
-  VERSION = "1.0.2"   
+  VERSION = "1.2.0"   
   
   class FormatterError < RuntimeError #:nodoc:
   end
@@ -79,6 +79,7 @@ module Ruport #:nodoc:#
         end 
         return $? == 0 ? size : [80,24] 
       end
+
    end
    
    def terminal_width
@@ -89,16 +90,16 @@ module Ruport #:nodoc:#
 
   # quiets warnings for block
   def quiet #:nodoc:
-    warnings = $VERBOSE
+    warns = $VERBOSE
     $VERBOSE = nil
     result = yield
-    $VERBOSE = warnings
+    $VERBOSE = warns
     return result
   end
 
   module_function :quiet
 
-end
+end  
 
 require "enumerator"
 require "ruport/renderer" 

data/lib/ruport/acts_as_reportable.rb

@@ -93,23 +93,32 @@ module Ruport
       #
       # Additional options include:
       #
-      # <b><tt>:only</tt></b>::     an attribute name or array of attribute
+      # <b><tt>:only</tt></b>::     An attribute name or array of attribute
       #                             names to include in the results, other
       #                             attributes will be excuded.
-      # <b><tt>:except</tt></b>::   an attribute name or array of attribute
+      # <b><tt>:except</tt></b>::   An attribute name or array of attribute
       #                             names to exclude from the results.
-      # <b><tt>:methods</tt></b>::  a method name or array of method names
+      # <b><tt>:methods</tt></b>::  A method name or array of method names
       #                             whose result(s) will be included in the
       #                             table.
-      # <b><tt>:include</tt></b>::  an associated model or array of associated
+      # <b><tt>:include</tt></b>::  An associated model or array of associated
       #                             models to include in the results.
-      # <b><tt>:record_class</tt></b>::  specify the class of the table's
+      # <b><tt>:filters</tt></b>::  A proc or array of procs that set up
+      #                             conditions to filter the data being added
+      #                             to the table.
+      # <b><tt>:transforms</tt></b>::  A proc or array of procs that perform
+      #                                transformations on the data being added
+      #                                to the table.
+      # <b><tt>:record_class</tt></b>::  Specify the class of the table's
       #                                  records.
+      # <b><tt>:eager_loading</tt></b>::  Set to false if you don't want to
+      #                                   eager load included associations.
       #
-      # The same set of options may be passed to the :include option in order to
-      # specify the output for any associated models. In this case, the
-      # :include option must be a hash, where the keys are the names of the
-      # associations and the values are hashes of options.
+      # The :only, :except, :methods, and :include options may also be passed
+      # to the :include option in order to specify the output for any
+      # associated models. In this case, the :include option must be a hash,
+      # where the keys are the names of the associations and the values
+      # are hashes of options.
       #
       # Any options passed to report_table will disable the options set by
       # the acts_as_reportable class method.
@@ -138,23 +147,21 @@ module Ruport
       # an html version of the table with all columns from books and authors.
       #
       # Note: column names for attributes of included models will be qualified
-      # with the model's underscored class name, e.g. 'author.name'
-      # By default, this will not preserve the entire namespace, but you
-      # can get the fully qualified namespace by using the
-      # :preserve_namespace => true option to report_table.  So if the
-      # Author model was enclosed in a module called MyModule, you'd
-      # get 'my_module/author.name' as the column name. 
+      # with the name of the association. 
       #
       def report_table(number = :all, options = {})
         only = options.delete(:only)
         except = options.delete(:except)
         methods = options.delete(:methods)
         includes = options.delete(:include)
-        preserve_namespace = options.delete(:preserve_namespace)
+        filters = options.delete(:filters) 
+        transforms = options.delete(:transforms)
         record_class = options.delete(:record_class) || Ruport::Data::Record
         self.aar_columns = []
 
-        options[:include] = get_include_for_find(includes)
+        unless options.delete(:eager_loading) == false
+          options[:include] = get_include_for_find(includes)
+        end
         
         data = [find(number, options)].flatten
         data = data.map {|r| r.reportable_data(:include => includes,
@@ -162,18 +169,25 @@ module Ruport
                                :except => except,
                                :methods => methods) }.flatten
 
+
         table = Ruport::Data::Table.new(:data => data,
                                         :column_names => aar_columns,
-                                        :record_class => record_class)
-        normalize_column_names(table) unless preserve_namespace
-        table
+                                        :record_class => record_class,
+                                        :filters => filters,
+                                        :transforms => transforms )
       end
       
       # Creates a Ruport::Data::Table from an ActiveRecord find_by_sql.
       #
       # Additional options include:
       #
-      # <b><tt>:record_class</tt></b>::  specify the class of the table's
+      # <b><tt>:filters</tt></b>::  A proc or array of procs that set up
+      #                             conditions to filter the data being added
+      #                             to the table.
+      # <b><tt>:transforms</tt></b>::  A proc or array of procs that perform
+      #                                transformations on the data being added
+      #                                to the table.
+      # <b><tt>:record_class</tt></b>::  Specify the class of the table's
       #                                  records.
       #
       # Example:
@@ -187,6 +201,8 @@ module Ruport
       #
       def report_table_by_sql(sql, options = {})
         record_class = options.delete(:record_class) || Ruport::Data::Record
+        filters = options.delete(:filters) 
+        transforms = options.delete(:transforms)
         self.aar_columns = []
 
         data = find_by_sql(sql)
@@ -194,22 +210,33 @@ module Ruport
 
         table = Ruport::Data::Table.new(:data => data,
                                         :column_names => aar_columns,
-                                        :record_class => record_class)
+                                        :record_class => record_class,
+                                        :filters => filters,
+                                        :transforms => transforms)
       end
 
       private
       
       def get_include_for_find(report_option)
         includes = report_option.blank? ? aar_options[:include] : report_option
-        includes.is_a?(Hash) ? includes.keys : includes
+        if includes.is_a?(Hash)
+          result = {}
+          includes.each do |k,v|
+            if v.empty? || !v[:include]
+              result.merge!(k => {})
+            else
+              result.merge!(k => get_include_for_find(v[:include]))
+            end
+          end
+          result
+        elsif includes.is_a?(Array)
+          result = {}
+          includes.each {|i| result.merge!(i => {}) }
+          result
+        else
+          includes
+        end
       end
-      
-      def normalize_column_names(table)
-        renamed = table.column_names.inject({}) do |s,c|
-           s.merge(c => c.sub(/.*\//,""))
-        end                              
-        table.rename_columns(renamed)
-     end
     end
     
     # === Overview
@@ -290,10 +317,10 @@ module Ruport
           data_records = []
           
           if include_has_options
-            assoc_options =
-              includes[association].merge({ :qualify_attribute_names => true })
+            assoc_options = includes[association].merge({
+              :qualify_attribute_names => association })
           else
-            assoc_options = { :qualify_attribute_names => true }
+            assoc_options = { :qualify_attribute_names => association }
           end
           
           association_objects = [send(association)].flatten.compact
@@ -327,8 +354,8 @@ module Ruport
       # 
       # Use the :only or :except options to limit the attributes returned.
       #
-      # Use the :qualify_attribute_names option to append the underscored
-      # model name to the attribute name as model.attribute
+      # Use the :qualify_attribute_names option to append the association
+      # name to the attribute name as association.attribute
       #
       def get_attributes_with_options(options = {})
         only_or_except =
@@ -336,9 +363,8 @@ module Ruport
             { :only => options[:only], :except => options[:except] }
           end
         attrs = attributes(only_or_except)
-        namespace = self.class.to_s.underscore
         attrs = attrs.inject({}) {|h,(k,v)|
-                  h["#{namespace}.#{k}"] = v; h
+                  h["#{options[:qualify_attribute_names]}.#{k}"] = v; h
                 } if options[:qualify_attribute_names]
         attrs
       end

data/lib/ruport/data.rb

@@ -1,3 +1,4 @@
 require "ruport/data/record" 
 require "ruport/data/table" 
 require "ruport/data/grouping"
+require "ruport/data/feeder"

data/lib/ruport/data/feeder.rb

@@ -0,0 +1,111 @@
+# Ruport : Extensible Reporting System                                
+#
+# data/feeder.rb provides a data transformation and filtering proxy for ruport
+#
+# Copyright August 2007, Gregory Brown / Michael Milner.  All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+
+# This class provides a simple way to apply transformations and filters that
+# get run while you are aggregating data.  This is used primarily to build
+# constrained wrappers to Ruport::Data::Table, but can be used with abstract
+# data structures as well.
+#
+# Table Example:
+#
+#   t = 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]
+#      feeder << [7,1,2]
+#      feeder << { "a" => 3, "b" => 6, "c" => 7 }
+#   end               
+#   t.length #=> 2
+#   t.column("b") #=> ["B: 2","B: 6"] 
+#   
+# Filters and transforms are added in a sequential order to a single list of
+# constraints.  You could add some constraints and then append some data, then
+# add additional constraints, or even build up dynamic constraints if you'd
+# like.
+#      
+# Wrapping an arbitrary data object:
+#
+# In order to make Data::Feeder work with an object other than Data::Table, it
+# must implement two things:
+#
+#  * A method called feed_element that accepts a single argument.  
+#    When Feeder#<< is called, the object to be appended is converted by this
+#    method, and then yielded to the filters / transforms.
+#
+#  * A meaningful #<< method.  Feeder#<< simply delegates this to the wrapped
+#    object once the filters and transforms have been applied, so be sure that
+#    the object returned by feed_element is one that can be used by your #<<
+#    method.
+#
+# Here is a sample implementation of wrapping a feeder around an Array.
+#
+#   class Array
+#     def feed_element(element)
+#       element
+#     end  
+#   end   
+#
+#   int_array = []
+#   feeder = Ruport::Data::Feeder.new(int_array)
+#   feeder.filter { |r| r.kind_of?(Integer) } 
+#
+#   feeder << 1 << "5" << 4.7 << "kitten" << 4 
+#   int_array #=> [1, 4]
+#
+class Ruport::Data::Feeder
+  
+  # Creates a new Data::Feeder, wrapping the data object provided. 
+  def initialize(data)   
+    @data = data   
+    @constraints = []
+  end                  
+  
+  # Accesses the underlying data object directly
+  attr_reader :data
+  
+  # Constrained append operation.
+  #  
+  # Before filters and transforms are run, the element to be appended is first
+  # converted by data.feed_element(some_element)
+  #
+  # Filters and transforms are then run sequentially, and if the constraints
+  # are met, it is appended using data << some_element.
+  #
+  def <<(element)  
+    feed_element = data.feed_element(element)
+     
+    @constraints.each do |type,block|
+      if type == :filter
+        return self unless block[feed_element]
+      else
+        block[feed_element]
+      end
+    end
+    
+    data << feed_element
+    return self
+  end
+     
+  # Creates a filter which must be satisfied for an object to be appended via
+  # the feeder.
+  #
+  #   feeder.filter { |r| r.length < 4 } 
+  #
+  def filter(&block)
+    @constraints << [:filter,block]
+  end 
+  
+  # Creates a transformation which may change the object as it is appended.
+  #
+  #   feeder.transform { |r| r.a += 10 }
+  def transform(&block)
+    @constraints << [:transform,block]
+  end
+  
+end