ruport 0.8.14 → 0.10.0

data/lib/ruport/renderer/grouping.rb

@@ -0,0 +1,67 @@
+module Ruport
+  
+  # This class implements the basic renderer for a single group of data.
+  #
+  # == Supported Formatters 
+  #
+  # * Formatter::CSV
+  # * Formatter::Text
+  # * Formatter::HTML
+  # * Formatter::PDF
+  #
+  # == Default layout options 
+  #
+  # * <tt>show_table_headers</tt> #=> true
+  #
+  # == Formatter hooks called (in order)
+  #
+  # * build_group_header
+  # * build_group_body
+  # * build_group_footer
+  #
+  class Renderer::Group < Renderer
+
+    option :show_table_headers
+
+    options { |o| o.show_table_headers = true }
+
+    stage :group_header, :group_body, :group_footer
+  end
+
+  # This class implements the basic renderer for data groupings in Ruport
+  # (a collection of Groups).
+  #
+  # == Supported Formatters 
+  #
+  # * Formatter::CSV
+  # * Formatter::Text
+  # * Formatter::HTML
+  # * Formatter::PDF
+  #
+  # == Default layout options 
+  #
+  # * <tt>show_group_headers</tt> #=> true
+  # * <tt>style</tt> #=> :inline
+  #
+  # == Formatter hooks called (in order)
+  #
+  # * build_grouping_header
+  # * build_grouping_body
+  # * build_grouping_footer
+  # * finalize_grouping
+  #
+  class Renderer::Grouping < Renderer
+
+    option :show_group_headers, :style
+
+    options do |o| 
+      o.show_group_headers = true 
+      o.style = :inline
+    end
+
+    stage :grouping_header, :grouping_body, :grouping_footer
+    
+    finalize :grouping
+  end
+  
+end

data/lib/ruport/renderer/table.rb

@@ -4,107 +4,38 @@
 # This is Free Software, please see LICENSE and COPYING for details.
 
 module Ruport
+
+  # This class implements the basic renderer for table rows.
   #
-  # This module provides some additional methods for Renderer::Table that may be
-  # helpful when rendering tabular data.
+  # == Supported Formatters 
+  #  
+  # * Formatter::CSV
+  # * Formatter::Text
+  # * Formatter::HTML
   #
-  # These methods assume you are working with Data::Table objects
-  module Renderer::TableHelpers
-
-    # Allows you to modify a column at rendering time based on a block.
-    # This will not effect the original data object you provided to the table
-    # renderer
-    #
-    # Example:
-    #
-    #   table.as(:text){ |r| r.rewrite_column("col1") { |a| a[0] + 5 }
-    #   table.as(:csv) { |r| r.rewrite_column(2) { |a| a.capitalize }
-    def rewrite_column(key,&block)
-      data.to_a.each { |r| r[key] = block[r] }
-    end
-
-    # Gets the number of columns in a table.  Useful in formatting plugins.
-    def num_cols
-      data[0].to_a.length
-    end
-
-    # Allows you to remove duplicates from data tables.
-    #
-    # By default, it will try to prune the entire table, but you may provide a
-    # limit of how many columns in it should work.
-    #
-    # Examples:
-    #
-    #   irb(main):014:0> puts a
-    #    +-----------+
-    #    | a | b | c |
-    #    +-----------+
-    #    | 1 | 2 | 3 |
-    #    | 1 | 2 | 2 |
-    #    | 1 | 3 | 5 |
-    #    | 2 | 7 | 9 |
-    #    | 2 | 8 | 3 |
-    #    | 2 | 7 | 1 |
-    #    | 1 | 7 | 9 |
-    #    +-----------+
-    #    => nil
-    #    irb(main):015:0> puts a.as(:text) { |e| e.prune(2) }
-    #    +-----------+
-    #    | a | b | c |
-    #    +-----------+
-    #    | 1 | 2 | 3 |
-    #    |   |   | 2 |
-    #    |   | 3 | 5 |
-    #    | 2 | 7 | 9 |
-    #    |   | 8 | 3 |
-    #    |   | 7 | 1 |
-    #    | 1 | 7 | 9 |
-    #    +-----------+
-    #    => nil
-    #    irb(main):016:0> puts a.as(:text) { |e| e.prune(1) }
-    #    +-----------+
-    #    | a | b | c |
-    #    +-----------+
-    #    | 1 | 2 | 3 |
-    #    |   | 2 | 2 |
-    #    |   | 3 | 5 |
-    #    | 2 | 7 | 9 |
-    #    |   | 8 | 3 |
-    #    |   | 7 | 1 |
-    #    | 1 | 7 | 9 |
-    #    +-----------+
-    def prune(limit=data[0].length)
-      require "enumerator"
-      limit.times do |field|
-        last = ""
-        data.each_cons(2) { |l,e|
-          next if field.nonzero? && e[field-1] 
-          last = l[field] if l[field]
-          e[field] = nil if e[field] == last
-        }
-      end
-    end
-
+  # == Formatter hooks called (in order)
+  #  
+  # * build_row
+  #
+  class Renderer::Row < Renderer
+    option :format_options
+    stage :row
   end
-  
+
   # This class implements the basic tabular data renderer for Ruport.
   #
-  # For a set of methods that might be helpful while working with this class,
-  # see the included TableHelpers module
-  #
-  # == Supported Format Plugins 
+  # == Supported Formatters 
   #  
-  # * Format::CSV
-  # * Format::Text
-  # * Format::HTML
-  # * Format::Latex
-  # * Format::PDF
+  # * Formatter::CSV
+  # * Formatter::Text
+  # * Formatter::HTML
+  # * Formatter::PDF
   #
   # == Default layout options 
   #  
   # * <tt>show_table_headers</tt> #=> true
   #
-  # == Plugin hooks called (in order)
+  # == Formatter hooks called (in order)
   #  
   # * prepare_table
   # * build_table_header
@@ -113,18 +44,14 @@ module Ruport
   # * finalize_table
   #
   class Renderer::Table < Renderer
-    include TableHelpers
-    include Renderer::Helpers
-     
-    add_formats :csv, :text, :html, :latex, :pdf
 
-    layout { |lay| lay.show_table_headers = true }
+    option :show_table_headers, :format_options
+
+    options { |o| o.show_table_headers = true }
 
     prepare :table
     
-    stage :table_header
-    stage :table_body
-    stage :table_footer
+    stage :table_header, :table_body, :table_footer
 
     finalize :table
   end

data/lib/ruport/report.rb

@@ -7,7 +7,6 @@
 
 #load the needed standard libraries.
 %w[erb yaml date logger fileutils].each { |lib| require lib }
-%w[graph].each { |lib| require "ruport/report/"+lib }
 require "forwardable"
 
 module Ruport
@@ -20,64 +19,19 @@ module Ruport
   # individual classes of the library, but if they are fairly simple, you may be
   # able to get away using this class alone.
   #
-  # === Example
-  #
-  # Here is a simple example of using the Report class to run a simple query and
-  # then email the results as a CSV file, deleting the file from the local
-  # machine after it has been emailed:
-  #
-  #  require "ruport"
-  #  require "fileutils"
-  #  class MyReport < Ruport::Report
-  #    def prepare
-  #      log_file "f.log"
-  #      log "preparing report", :status => :info
-  #      source :default, 
-  #        :dsn => "dbi:mysql:foo", 
-  #        :user => "root"
-  #      mailer :default,
-  #        :host => "mail.adelphia.net", 
-  #        :address => "gregory.t.brown@gmail.com"
-  #    end
-  #      
-  #    def generate
-  #      log "generated csv from query", :status => :info
-  #      query "select * from bar", :as => :csv 
-  #    end
-  #
-  #    def cleanup
-  #      log "removing foo.csv", :status => :info
-  #      FileUtils.rm("foo.csv") 
-  #    end
-  #  end
-  #
-  #  MyReport.run { |res| 
-  #    res.write "foo.csv";
-  #    res.send_to("greg7224@gmail.com") do |mail|
-  #      mail.subject = "Sample report" 
-  #      mail.attach "foo.csv"
-  #      mail.text = <<-EOS
-  #        this is a sample of sending an emailed report from within Ruport.
-  #      EOS
-  #    end
-  #  } 
-  #
-  # 
+  # FIXME: New example
   class Report   
     extend Forwardable
+    include Renderer::Hooks
     
-    # 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.
-    #
     # If your report does not need any sort of specialized information, you can
     # simply use Report.run (Or MyReportName.run if you've inherited).
     #
     # This will auto-initialize a report.
     #
-    def initialize( source_name=:default, mailer_name=:default )
-      use_source source_name
-      use_mailer mailer_name
+    def initialize( format=nil, options={} )
+      use_source :default
+      @format      = format
       @report_name = "" 
       @results     = ""
       @file        = nil
@@ -91,6 +45,8 @@ module Ruport
     #
     attr_accessor :results
 
+    attr_accessor :format
+
     # This is a simplified interface to Ruport::Query.
     #
     # You can use it to read SQL statements from file or string:
@@ -128,7 +84,6 @@ module Ruport
     def query(sql, options={})
       options[:origin] ||= :string
       options[:source] ||= @source
-      options[:binding] ||= binding
       q = options[:query_obj] || Query.new(sql, options)
       if block_given?
         q.each { |r| yield(r) }
@@ -139,27 +94,15 @@ module Ruport
       end
     end
     
-    # Sets the active source to the Ruport::Config source requested by <tt>label</tt>.
+    # Sets the active source to the Ruport::Query source requested by <tt>label</tt>.
     def use_source(label)
       @source = label
     end
 
-    # Sets the active mailer to the Ruport::Config source requested by <tt>label</tt>.
-    def use_mailer(label)
-      @mailer = label
-    end
-    
-    # Writes the contents of <tt>results</tt> to a 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,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
-    # the file already exists.
-    #
     def append(my_file=file,my_results=results)
       File.open(my_file,"a") { |f| f << my_results }
     end
@@ -173,6 +116,16 @@ module Ruport
       self.class.run(options,&block)
     end
 
+    def as(format,*args)
+      self.format = format
+      run(*args)
+    end
+
+    def method_missing(id,*args)
+      id.to_s =~ /^to_(.*)/
+      $1 ? as($1.to_sym,*args) : super
+    end
+
     # Loads a CSV in from  a file.
     #
     # Example:
@@ -212,37 +165,18 @@ module Ruport
       end
     end
 
-    # uses RedCloth to turn a string containing textile markup into HTML.
-    #
-    # Example:
-    #
-    #   textile "*bar*" #=> "<p><strong>foo</strong></p>"
-    #
-    def textile(s)
-      require "redcloth"
-      RedCloth.new(s).to_html
-    end
-    
-    # Allows logging and other fun stuff. 
-    # See also Ruport.log
-    #
-    def log(*args); Ruport.log(*args) end
-   
-    # Creates a new Mailer and sets the <tt>to</tt> attribute to the addresses
-    # specified. Yields a Mailer object, which can be modified before delivery.
-    #
-    def send_to(adds)
-      m = Mailer.new
-      m.to = adds
-      yield(m)
-      m.send(:select_mailer,@mailer)
-      m.deliver :from => m.from, :to => m.to
-    end
-    
-    def_delegators Ruport::Config, :source, :mailer, :log_file, :log_file=
-    
     class << self
 
+      def as(format,options={})
+        report = new(format)
+        report.run(rendering_options.merge(options))
+      end
+
+      def method_missing(id,*args)
+        id.to_s =~ /^to_(.*)/
+        $1 ? as($1.to_sym,*args) : super
+      end
+
       # Defines an instance method which will be run before the
       # <tt>generate</tt> method when Ruport.run is executed.
       #
@@ -263,7 +197,7 @@ module Ruport
       def cleanup(&block); define_method(:cleanup,&block) end
 
       private :prepare, :generate, :cleanup
-      
+
       # Runs the reports specified.  If no reports are specified, then it
       # creates a new instance via <tt>self.new</tt>.
       #
@@ -279,10 +213,26 @@ module Ruport
       def run(options={})
         options[:reports] ||= [self.new]
 
+        formatting_options = ( options.keys - 
+                                [:reports,:tries,:timeout,:interval])
+
+        fopts = formatting_options.inject({}) { |s,k|
+          s.merge( k => options[k] )
+        }
+        
+
         process = lambda do
           options[:reports].each { |rep|
             rep.prepare if rep.respond_to? :prepare
             rep.results = rep.generate
+
+            if renderer
+              rep.results = 
+                renderer.render(rep.format,rendering_options.merge(fopts)) { |r| 
+                r.data = rep.results
+              }
+            end
+
             yield(rep) if block_given?
             rep.cleanup if rep.respond_to? :cleanup
           }
@@ -293,7 +243,6 @@ module Ruport
             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

data/test/acts_as_reportable_test.rb

@@ -0,0 +1,229 @@
+require "ruport"
+require "test/unit"
+
+begin 
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+
+begin
+  require 'mocha'
+  require 'stubba'
+  require 'active_record'
+rescue LoadError
+  nil
+end
+
+if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
+
+  require "ruport/acts_as_reportable"
+
+  class Team < ActiveRecord::Base
+    acts_as_reportable :except => 'id', :include => :players
+    has_many :players
+  end
+
+  class Player < ActiveRecord::Base
+    acts_as_reportable
+    belongs_to :team
+    belongs_to :personal_trainer
+  
+    def stats
+      "#{name} stats"
+    end
+  end
+  
+  module SomeModule
+    
+    class PersonalTrainer < ActiveRecord::Base
+      acts_as_reportable
+      has_one :team
+      has_many :players
+    end
+    
+  end
+  
+  class TestActsAsReportable < Test::Unit::TestCase
+    Column = ActiveRecord::ConnectionAdapters::Column
+    PersonalTrainer = SomeModule::PersonalTrainer
+  
+    def setup    
+      setup_column_stubs
+
+      @trainers = []
+      @trainers << PersonalTrainer.new(:name => "Trainer 1")
+      @trainers << PersonalTrainer.new(:name => "Trainer 2")
+      @teams = []
+      @teams << Team.new( :name   => "Testers",
+                          :league => "My League")
+      @teams << Team.new( :name   => "Others",
+                          :league => "Other League")
+      @players = []
+      @players << Player.new( :team_id  => 1,
+                              :name     => "Player 1",
+                              :personal_trainer_id  => 1)
+      @players << Player.new( :team_id  => 1,
+                              :name     => "Player 2",
+                              :personal_trainer_id  => 2)
+    
+      setup_find_stubs
+    end
+
+    def test_options_set
+      assert_equal({:except => 'id', :include => :players}, Team.aar_options)
+    end
+  
+    def test_basic_report_table
+      actual = Player.report_table
+      expected = [[1, "Player 1", 1],
+        [1, "Player 2", 2]].to_table(%w[team_id name personal_trainer_id])
+      assert_equal expected, actual
+    end
+    
+    def test_only
+      actual = Player.report_table(:all, :only => 'name')
+      expected = [["Player 1"],["Player 2"]].to_table(%w[name])
+      assert_equal expected, actual
+    end
+      
+    def test_except
+      actual = Player.report_table(:all, :except => 'personal_trainer_id')
+      expected = [[1, "Player 1"],[1, "Player 2"]].to_table(%w[team_id name])
+      assert_equal expected, actual
+    end
+      
+    def test_methods
+      actual = Player.report_table(:all, :only => 'name', :methods => :stats)
+      expected = [["Player 1", "Player 1 stats"],
+                  ["Player 2", "Player 2 stats"]].to_table(%w[name stats])
+      assert_equal expected, actual
+    end
+      
+    def test_include
+      actual = Player.report_table(:all, :only => 'name',
+        :include => :personal_trainer)
+      expected = [["Player 1", "Trainer 1"],
+        ["Player 2", "Trainer 2"]].to_table(%w[name personal_trainer.name])
+      assert_equal expected, actual
+    end
+      
+    def test_include_with_options
+      actual = Team.report_table(:all, :only => 'name',
+        :include => { :players => { :only => 'name' } })
+      expected = [["Testers", "Player 1"],
+        ["Testers", "Player 2"],
+        ["Others", nil]].to_table(%w[name player.name])
+      assert_equal expected, actual
+    end
+
+    def test_get_include_for_find
+      assert_equal :players, Team.send(:get_include_for_find, nil)
+      assert_equal nil, Player.send(:get_include_for_find, nil)
+      assert_equal :team, Player.send(:get_include_for_find, :team)
+      assert_equal [:team],
+        Player.send(:get_include_for_find, {:team => {:except => 'id'}})
+    end
+
+    def test_reportable_data
+      actual = @players[0].reportable_data
+      expected = [{ 'team_id' => 1,
+                    'name' => "Player 1",
+                    'personal_trainer_id' => 1 }]
+      assert_equal expected, actual
+
+      actual = @teams[0].reportable_data(:include =>
+        { :players => { :only => 'name' } })
+      expected = [{ 'name' => "Testers",
+                    'league' => "My League",
+                    'player.name' => "Player 1" },
+                    { 'name' => "Testers",
+                    'league' => "My League",
+                    'player.name' => "Player 2" }]
+      assert_equal expected, actual
+    end
+    
+    def test_add_includes
+      actual = @players[0].send(:add_includes,
+        [{ 'name' => "Player 1" }], :personal_trainer)
+      expected = [{ 'name' => "Player 1",
+                    'some_module/personal_trainer.name' => "Trainer 1" }]
+      assert_equal expected, actual
+    end
+    
+    def test_has_report_options
+      assert @teams[0].send(:has_report_options?, { :only => 'name' })
+      assert @teams[0].send(:has_report_options?, { :except => 'name' })
+      assert @teams[0].send(:has_report_options?, { :methods => 'name' })
+      assert @teams[0].send(:has_report_options?, { :include => 'name' })
+      assert !@teams[0].send(:has_report_options?, { :foo => 'name' })
+    end
+  
+    def test_preserve_namespace_option
+      actual = Player.report_table(:all, :only => 'name',
+        :include => :personal_trainer, :preserve_namespace => true)
+      expected = [["Player 1", "Trainer 1"],
+        ["Player 2", "Trainer 2"]].to_table(%w[name
+        some_module/personal_trainer.name])
+      assert_equal expected, actual
+    end
+    
+    def test_get_attributes_with_options
+      actual = @players[0].send(:get_attributes_with_options)
+      expected = { 'team_id' => 1,
+                   'name' => "Player 1",
+                   'personal_trainer_id' => 1 }
+      assert_equal expected, actual
+
+      actual = @players[0].send(:get_attributes_with_options,
+        { :only => 'name' })
+      expected = { 'name' => "Player 1" }
+      assert_equal expected, actual
+
+      actual = @players[0].send(:get_attributes_with_options,
+        { :except => 'personal_trainer_id' })
+      expected = { 'team_id' => 1,
+                   'name' => "Player 1" }
+      assert_equal expected, actual
+
+      actual = @players[0].send(:get_attributes_with_options,
+        { :only => 'name', :qualify_attribute_names => true })
+      expected = { 'player.name' => "Player 1" }
+      assert_equal expected, actual
+    end
+
+    private
+  
+    def setup_column_stubs
+      PersonalTrainer.stubs(:columns).returns([
+        Column.new("id", nil, "integer", false),
+        Column.new("name", nil, "string", false)])
+      Team.stubs(:columns).returns([Column.new("id", nil, "integer", false),
+        Column.new("name", nil, "string", false),
+        Column.new("league", nil, "string", true)])
+      Player.stubs(:columns).returns([Column.new("id", nil, "integer", false),
+        Column.new("team_id", nil, "integer", true),
+        Column.new("name", nil, "string", false),
+        Column.new("personal_trainer_id", nil, "integer", true)])
+    end
+  
+    def setup_find_stubs
+      PersonalTrainer.stubs(:find).returns(@trainers)
+      @trainers[0].stubs(:players).returns([@players[0]])
+      @trainers[1].stubs(:players).returns([@players[1]])
+      Team.stubs(:find).returns(@teams)
+      @teams[0].stubs(:players).returns(@players)
+      @teams[1].stubs(:players).returns([])
+      Player.stubs(:find).returns(@players)
+      @players[0].stubs(:team).returns(@teams[0])
+      @players[1].stubs(:team).returns(@teams[0])
+      @players[0].stubs(:personal_trainer).returns(@trainers[0])
+      @players[1].stubs(:personal_trainer).returns(@trainers[1])
+    end
+  
+  end
+
+else
+  $stderr.puts "Warning: Mocha and/or ActiveRecord not found -- skipping AAR tests"
+end