ruport 0.11.0 → 0.12.0

data/README

@@ -1,10 +1,10 @@
 # ------------------------------------------------------------------------
 # Contents:
 # 
-#  - What Ruport Is
-#  - Installation
-#  - Resources
-#  - Hacking
+#  + What Ruport Is
+#  + Installation
+#  + Resources
+#  + Hacking
 #
 # = What Ruport Is
 #

data/Rakefile

@@ -3,7 +3,7 @@ require "rake/testtask"
 require "rake/gempackagetask"
 
 
-RUPORT_VERSION = "0.11.0"
+RUPORT_VERSION = "0.12.0"
 
 begin
   require "rubygems"

data/lib/ruport.rb

@@ -12,7 +12,7 @@
 
 module Ruport #:nodoc:#
   
-  VERSION = "0.11.0"   
+  VERSION = "0.12.0"   
   
   class FormatterError < RuntimeError #:nodoc:
   end

data/lib/ruport/acts_as_reportable.rb

@@ -103,6 +103,8 @@ module Ruport
       #                             table.
       # <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
+      #                                  records.
       #
       # 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
@@ -149,6 +151,7 @@ module Ruport
         methods = options.delete(:methods)
         includes = options.delete(:include)
         preserve_namespace = options.delete(:preserve_namespace)
+        record_class = options.delete(:record_class) || Ruport::Data::Record
         self.aar_columns = []
 
         options[:include] = get_include_for_find(includes)
@@ -159,12 +162,41 @@ module Ruport
                                :except => except,
                                :methods => methods) }.flatten
 
-        table =
-          Ruport::Data::Table.new(:data => data, :column_names => aar_columns)
+        table = Ruport::Data::Table.new(:data => data,
+                                        :column_names => aar_columns,
+                                        :record_class => record_class)
         normalize_column_names(table) unless preserve_namespace
         table
       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
+      #                                  records.
+      #
+      # Example:
+      # 
+      #   class Book < ActiveRecord::Base
+      #     belongs_to :author
+      #     acts_as_reportable
+      #   end
+      #
+      #   Book.report_table_by_sql("SELECT * FROM books")
+      #
+      def report_table_by_sql(sql, options = {})
+        record_class = options.delete(:record_class) || Ruport::Data::Record
+        self.aar_columns = []
+
+        data = find_by_sql(sql)
+        data = data.map {|r| r.reportable_data }.flatten
+
+        table = Ruport::Data::Table.new(:data => data,
+                                        :column_names => aar_columns,
+                                        :record_class => record_class)
+      end
+
       private
       
       def get_include_for_find(report_option)

data/lib/ruport/data/grouping.rb

@@ -173,10 +173,6 @@ module Ruport::Data
     # The name of the column used to group the data
     attr_reader :grouped_by
     
-    require "forwardable"
-    extend Forwardable
-    def_delegator :@data, :each
-    
     # Allows Hash-like indexing of the grouping data.
     #
     # Examples:
@@ -186,6 +182,12 @@ module Ruport::Data
     def [](name)
       @data[name] or 
         raise(IndexError,"Group Not Found")
+    end                    
+    
+    # Iterates through the Grouping, yielding each group name and Group object
+    #
+    def each
+      @data.each { |name,group| yield(name,group) }
     end 
     
     # Used to add extra data to the Grouping. <tt>group</tt> should be a Group.

data/lib/ruport/formatter/pdf.rb

@@ -39,7 +39,45 @@ module Ruport
   #     Grouping:
   #       * style (:inline,:justified,:separated,:offset)
   #
-  class Formatter::PDF < Formatter    
+  class Formatter::PDF < Formatter          
+    
+    ## THESE ARE WHY YOU SHOULD NEVER USE PDF::Writer 
+    
+    module PDFWriterMemoryPatch #:nodoc:
+      unless self.class.instance_methods.include?("_post_transaction_rewind")
+        def _post_transaction_rewind
+          @objects.each { |e| e.instance_variable_set(:@parent,self) }
+        end
+      end
+    end    
+    
+    module PDFSimpleTableOrderingPatch #:nodoc:
+      def __find_table_max_width__(pdf)      
+         #p "this actually gets called"
+         max_width = PDF::Writer::OHash.new(-1)
+
+           # Find the maximum cell widths based on the data and the headings.
+           # Passing through the data multiple times is unavoidable as we must do
+           # some analysis first.
+         @data.each do |row|
+           @cols.each do |name, column|
+             w = pdf.text_width(row[name].to_s, @font_size)
+             w *= PDF::SimpleTable::WIDTH_FACTOR
+
+             max_width[name] = w if w > max_width[name]
+           end
+         end
+
+         @cols.each do |name, column|
+           title = column.heading.title if column.heading
+           title ||= column.name
+           w = pdf.text_width(title, @heading_font_size)
+           w *= PDF::SimpleTable::WIDTH_FACTOR  
+           max_width[name] = w if w > max_width[name]
+         end
+         max_width
+      end
+    end
     
     renders :pdf, :for => [ Renderer::Row, Renderer::Table,
                             Renderer::Group, Renderer::Grouping ]
@@ -54,7 +92,7 @@ module Ruport
                 :paper_orientation
 
     def initialize
-      quiet do
+      quiet do   
         require "pdf/writer"
         require "pdf/simpletable"
       end
@@ -274,15 +312,15 @@ module Ruport
       
       format_opts = table_format.merge(format_opts) if table_format  
       
-      ::PDF::SimpleTable.new do |table|              
-        table.data = table_data  
+      ::PDF::SimpleTable.new do |table| 
+        table.extend(PDFSimpleTableOrderingPatch)             
         table.maximum_width = 500
-        table.column_order  = table_data.column_names                                            
-          
+        table.column_order  = table_data.column_names
+        table.data = table_data
+        table.data = [{}] if table.data.empty?                                                 
         apply_pdf_table_column_opts(table,table_data,format_opts)
 
-        format_opts.each {|k,v| table.send("#{k}=", v) }
-
+        format_opts.each {|k,v| table.send("#{k}=", v) }  
         table.render_on(pdf_writer)
       end
     end
@@ -296,7 +334,14 @@ module Ruport
       def horizontal_line(x1,x2)
         pdf_writer.line(x1,cursor,x2,cursor)
         pdf_writer.stroke
-      end
+      end 
+      
+      # draws a horizontal line from left_boundary to right_boundary
+      def horizontal_rule
+        horizontal_line(left_boundary,right_boundary)                                            
+      end                                            
+      
+      alias_method :hr, :horizontal_rule
                     
       # draws a vertical line at x from y1 to y2
       def vertical_line_at(x,y1,y2)
@@ -343,14 +388,6 @@ module Ruport
     end   
 
     include DrawingHelpers
-     
-    module PDFWriterMemoryPatch #:nodoc:
-      unless self.class.instance_methods.include?("_post_transaction_rewind")
-        def _post_transaction_rewind
-          @objects.each { |e| e.instance_variable_set(:@parent,self) }
-        end
-      end
-    end
     
     private   
     

data/lib/ruport/formatter/text.rb

@@ -55,7 +55,8 @@ module Ruport
     # calculate_max_col_widths
     #
     def prepare_table
-      raise "Can't output empty table" if data.empty?
+      raise Ruport::FormatterError, "Can't output table without " +
+        "data or column names." if data.empty? && data.column_names.empty?
       calculate_max_col_widths
     end
 
@@ -84,6 +85,7 @@ module Ruport
     #
     def build_table_body
       output << fit_to_width(hr)
+      return if data.empty?
 
       calculate_max_col_widths unless max_col_width
 
@@ -154,8 +156,9 @@ module Ruport
     #
     #   "+------------------+"
     def hr
-      len = max_col_width.inject(data[0].to_a.length * 3) {|s,e|s+e}+1
-      "+" + "-"*(len-2) + "+\n"
+      ref = data.column_names.empty? ? data[0].to_a : data.column_names
+      len = max_col_width.inject(ref.length * 3) {|s,e|s+e}
+      "+" + "-"*(len-1) + "+\n"
     end
     
     # Returns options.table_width if specified.

data/test/acts_as_reportable_test.rb

@@ -1,24 +1,19 @@
-require "ruport"
-require "test/unit"
-
-begin 
-  require "rubygems"
-rescue LoadError
-  nil
-end
-
+require "test/unit"      
+require "ruport"         
 
 begin
-  require 'mocha'
-  require 'stubba'
-  require 'active_record'
+  require "rubygems"  
+  gem "mocha", ">=0.4.0"
+  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"
 
-  require "ruport/acts_as_reportable"
+if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
 
   class Team < ActiveRecord::Base
     acts_as_reportable :except => 'id', :include => :players
@@ -36,20 +31,18 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
   end
   
   module SomeModule
-    
     class PersonalTrainer < ActiveRecord::Base
       acts_as_reportable
       has_one :team
       has_many :players
     end
-    
   end
   
-  class TestActsAsReportable < Test::Unit::TestCase
+  module ModelStubsSetup
     Column = ActiveRecord::ConnectionAdapters::Column
     PersonalTrainer = SomeModule::PersonalTrainer
-  
-    def setup    
+    
+    def setup
       setup_column_stubs
 
       @trainers = []
@@ -70,11 +63,49 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
     
       setup_find_stubs
     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)
+      Player.stubs(:find_by_sql).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
+
 
-    def test_options_set
+  class TestActsAsReportableClassMethods < Test::Unit::TestCase
+    
+    def test_aar_options_set
       assert_equal({:except => 'id', :include => :players}, Team.aar_options)
     end
-  
+  end
+
+  class TestActsAsReportableSingletonMethods < Test::Unit::TestCase
+    include ModelStubsSetup
+    
     def test_basic_report_table
       actual = Player.report_table
       expected = [[1, "Player 1", 1],
@@ -82,26 +113,33 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       assert_equal expected, actual
     end
     
-    def test_only
+    def test_report_table_by_sql
+      actual = Player.report_table_by_sql("SELECT * FROM players")
+      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_option
       actual = Player.report_table(:all, :only => 'name')
       expected = [["Player 1"],["Player 2"]].to_table(%w[name])
       assert_equal expected, actual
     end
       
-    def test_except
+    def test_except_option
       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
+    def test_methods_option
       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
+    def test_include_option
       actual = Player.report_table(:all, :only => 'name',
         :include => :personal_trainer)
       expected = [["Player 1", "Trainer 1"],
@@ -109,7 +147,7 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       assert_equal expected, actual
     end
       
-    def test_include_with_options
+    def test_include_has_options
       actual = Team.report_table(:all, :only => 'name',
         :include => { :players => { :only => 'name' } })
       expected = [["Testers", "Player 1"],
@@ -117,6 +155,26 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
         ["Others", nil]].to_table(%w[name player.name])
       assert_equal expected, actual
     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
+    
+    class CustomRecord < Ruport::Data::Record; end
+
+    def test_record_class_option
+      actual = Player.report_table(:all, :record_class => CustomRecord)
+      actual.each { |r| assert_equal CustomRecord, r.class }
+
+      actual = Player.report_table_by_sql("SELECT * FROM players",
+                 :record_class => CustomRecord)
+      actual.each { |r| assert_equal CustomRecord, r.class }
+    end
 
     def test_get_include_for_find
       assert_equal :players, Team.send(:get_include_for_find, nil)
@@ -124,15 +182,19 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       assert_equal :team, Player.send(:get_include_for_find, :team)
       assert_equal [:team],
         Player.send(:get_include_for_find, {:team => {:except => 'id'}})
-    end
-
+    end  
+  end
+    
+  class TestActsAsReportableInstanceMethods < Test::Unit::TestCase
+    include ModelStubsSetup
+    
     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",
@@ -159,69 +221,30 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       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