ruport 1.0.2 → 1.2.0

data/test/acts_as_reportable_test.rb

@@ -1,15 +1,17 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
+
 begin
   require "mocha"
-  require "stubba"
-  require "active_record"
+  require "stubba"      
+  Ruport.quiet { 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"   
 
   class Team < ActiveRecord::Base
     acts_as_reportable :except => 'id', :include => :players
@@ -148,16 +150,7 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
         :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_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])
+        ["Others", nil]].to_table(%w[name players.name])
       assert_equal expected, actual
     end
     
@@ -176,8 +169,15 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       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],
+      expected = {:team => {}}
+      assert_equal expected,
         Player.send(:get_include_for_find, {:team => {:except => 'id'}})
+      expected = {:team => {:a => {}, :b => {}},
+        :c => {:d => {:e => {}, :f => {}}},
+        :g => {}}
+      assert_equal expected,
+        Player.send(:get_include_for_find, {:team => {:include => [:a,:b]},
+        :c => {:include => {:d => {:include => [:e,:f]}}}, :g => {}})
     end  
   end
     
@@ -195,10 +195,10 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
         { :players => { :only => 'name' } })
       expected = [{ 'name' => "Testers",
                     'league' => "My League",
-                    'player.name' => "Player 1" },
+                    'players.name' => "Player 1" },
                     { 'name' => "Testers",
                     'league' => "My League",
-                    'player.name' => "Player 2" }]
+                    'players.name' => "Player 2" }]
       assert_equal expected, actual
     end
     
@@ -206,7 +206,7 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       actual = @players[0].send(:add_includes,
         [{ 'name' => "Player 1" }], :personal_trainer)
       expected = [{ 'name' => "Player 1",
-                    'some_module/personal_trainer.name' => "Trainer 1" }]
+                    'personal_trainer.name' => "Trainer 1" }]
       assert_equal expected, actual
     end
     
@@ -237,8 +237,8 @@ if Object.const_defined?(:ActiveRecord) && Object.const_defined?(:Mocha)
       assert_equal expected, actual
     
       actual = @players[0].send(:get_attributes_with_options,
-        { :only => 'name', :qualify_attribute_names => true })
-      expected = { 'player.name' => "Player 1" }
+        { :only => 'name', :qualify_attribute_names => :players })
+      expected = { 'players.name' => "Player 1" }
       assert_equal expected, actual
     end
   end

data/test/csv_formatter_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestRenderCSVRow < Test::Unit::TestCase
   def test_render_csv_row
@@ -34,6 +35,30 @@ class TestRenderCSVTable < Test::Unit::TestCase
     assert_equal("1,2,3\n4,5,6\n",actual)
   end
      
+  def test_render_with_template
+    Ruport::Formatter::Template.create(:simple) do |t|
+      t.table_format = {
+        :show_headings  => false
+      }
+      t.grouping_format = {
+        :style          => :justified,
+        :show_headings  => false
+      }
+      t.format_options = { :col_sep => ":" }
+    end
+
+    formatter = Ruport::Formatter::CSV.new
+    formatter.options = Ruport::Renderer::Options.new
+    formatter.options.template = :simple
+    formatter.apply_template
+    
+    assert_equal false, formatter.options.show_table_headers
+
+    assert_equal :justified, formatter.options.style
+    assert_equal false, formatter.options.show_group_headers
+    
+    assert_equal ":", formatter.options.format_options[:col_sep]
+  end
 end     
 
 class TestRenderCSVGroup < Test::Unit::TestCase

data/test/data_feeder_test.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")    
+
+class DataFeederTest < Test::Unit::TestCase
+   
+  context "when using a default data feeder" do
+      
+    def setup
+      @feeder = Ruport::Data::Feeder.new(Table(%w[a b c]))      
+    end    
+    
+    def specify_data_attribute_should_return_wrapped_data
+      assert_equal Table(%w[a b c]), @feeder.data  
+    end
+     
+    def specify_append_should_forward_to_wrapped_data_by_default
+      t = Table(%w[a b c])
+      t << [1,2,3] << {"a" => 2, "b" => 3, "c" => 4}
+      @feeder << [1,2,3] << {"a" => 2, "b" => 3, "c" => 4} 
+      assert_equal t, @feeder.data 
+    end  
+    
+  end 
+  
+  context "when using a feeder with a filter" do
+     def setup 
+       @feeder = Ruport::Data::Feeder.new(Table(%w[a b c]))
+       @feeder.filter { |r| r.a != 1 }
+     end    
+     
+     def specify_filter_should_only_append_rows_for_which_block_is_true
+       @feeder << [1,2,3] << [4,1,2] << [3,1,1] << [1,2,5]
+       assert_equal Table(%w[a b c], :data => [[4,1,2],[3,1,1]]), @feeder.data  
+     end
+  end 
+  
+  context "when using a feeder with a transform" do
+     def setup
+       @feeder = Ruport::Data::Feeder.new(Table(%w[a b c])) 
+       @feeder.transform { |r| r.a += 1 }
+     end
+     
+     def specify_filter_should_be_applied_to_all_rows
+       @feeder << [1,2,3] << [4,1,2] << [3,1,1] << [1,2,5]
+       assert_equal Table(%w[a b c], :data => [[2,2,3],[5,1,2],[4,1,1],[2,2,5]]),
+                    @feeder.data
+     end     
+  end  
+  
+  context "when using a feeder and a filter together" do
+    def setup
+      @feeder = Ruport::Data::Feeder.new(Table(%w[a b c]))
+    end 
+    
+    def specify_filter_is_called_first_when_defined_first
+      @feeder.filter { |r| r.b != 2 }
+      @feeder.transform { |r| r.b += 1 }
+      @feeder << [1,2,3] << [4,1,2] << [3,1,1] << [1,2,5] 
+      assert_equal Table(%w[a b c], :data => [[4,2,2],[3,2,1]]),
+                   @feeder.data
+    end
+    
+    def specify_transform_is_called_first_when_defined_first
+      @feeder.transform { |r| r.b += 1 }                    
+      @feeder.filter { |r| r.b != 2 }      
+      @feeder << [1,2,3] << [4,1,2] << [3,1,1] << [1,2,5] 
+      assert_equal Table(%w[a b c], :data => [[1,3,3],[1,3,5]]),
+                   @feeder.data
+    end 
+  end      
+  
+  context "when using many feeders and filters together" do
+    def setup
+      @feeder = Ruport::Data::Feeder.new(Table(%w[a b c])) 
+      @feeder.transform { |r| r.a += 1 }      
+      @feeder.filter { |r| r.a > 5 }
+      @feeder.transform { |r| r.b = r.b.to_s } 
+      @feeder.filter { |r| r.b == "3" } 
+   end
+   
+   def specify_all_blocks_are_executed_in_order
+     @feeder << [1,2,3] << [4,1,9] << [5,3,1] << [2,3,0] << [7,3,5] 
+     assert_equal Table(%w[a b c], :data => [[6,"3",1],[8,"3",5]]),
+                  @feeder.data
+   end  
+ end
+  
+end

data/test/grouping_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w   
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestGroup < Test::Unit::TestCase
 
@@ -232,7 +233,8 @@ class TestGrouping < Test::Unit::TestCase
   end
   
   def test_grouping_summary
-    source = Table("test/samples/ticket_count.csv",
+    source = Table(File.join(File.expand_path(File.dirname(__FILE__)), 
+                   *%w[samples ticket_count.csv]),
                      :record_class => TicketStatus)
     grouping = Grouping(source,:by => "date")
     
@@ -254,8 +256,92 @@ class TestGrouping < Test::Unit::TestCase
       :opened => lambda { |g| g.sigma(:opened) },
       :closed => lambda { |g| g.sigma(:closed) }
       
-    assert_equal [], expected.column_names - actual.column_names
-  end   
+    assert_equal [], expected.column_names - actual.column_names       
+  end                                                              
+  
+  def test_grouping_sigma
+    assert_respond_to @grouping, :sigma
+    assert_respond_to @grouping, :sum
+    
+    expected = {}
+    @grouping.data[@grouping.data.keys.first].column_names.each do |col|
+      expected[col] = @grouping.inject(0) do |s, (group_name, group)|
+        s + group.sigma(col)
+      end
+    end
+    expected.keys.each do |col|
+      assert_equal expected[col], @grouping.sigma(col)
+    end
+
+    expected = {}
+    @grouping.data[@grouping.data.keys.first].column_names.each do |col|
+      expected[col] = @grouping.inject(0) do |s, (group_name, group)|
+        s + group.sigma {|r| r[col] + 2 }
+      end
+    end
+    expected.keys.each do |col|
+      assert_equal expected[col], @grouping.sigma {|r| r[col] + 2 }
+    end
+  end
+
+  context "when sorting groupings" do
+    
+    def setup
+      @table = Table(%w[a b c]) << ["dog",1,2] << ["cat",3,5] << 
+                                   ["banana",8,1] << ["dog",5,6]
+    end
+    
+    def specify_can_set_by_group_name_order_in_constructor
+      a = Grouping(@table, :by => "a", :order => :name)    
+      names = %w[banana cat dog]           
+      data = [ [[8,1]], [[3,5]], [[1,2],[5,6]] ]
+      a.each do |name,group|
+        assert_equal names.shift, name
+        assert_equal data.shift, group.map { |r| r.to_a } 
+      end
+    end
+    
+    def specify_can_set_by_proc_ordering_in_constructor
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } ) 
+      names = %w[dog banana cat]      
+      data = [ [[1,2],[5,6]], [[8,1]], [[3,5]] ]
+      a.each do |name,group|
+        assert_equal names.shift, name
+        assert_equal data.shift, group.map { |r| r.to_a } 
+      end
+    end  
+    
+    def specify_can_override_sorting
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )  
+      a.sort_grouping_by!(:name)
+      names = %w[banana cat dog]           
+      data = [ [[8,1]], [[3,5]], [[1,2],[5,6]] ]
+      a.each do |name,group|
+        assert_equal names.shift, name
+        assert_equal data.shift, group.map { |r| r.to_a } 
+      end
+    end 
+    
+    def specify_can_get_a_new_sorted_grouping
+      a = Grouping(@table, :by => "a", :order => lambda { |g| -g.length } )  
+      b = a.sort_grouping_by(:name)     
+      
+      names = %w[banana cat dog]           
+      data = [ [[8,1]], [[3,5]], [[1,2],[5,6]] ]
+      b.each do |name,group|
+        assert_equal names.shift, name
+        assert_equal data.shift, group.map { |r| r.to_a } 
+      end
+      
+      # assert original retained
+      names = %w[dog banana cat]      
+      data = [ [[1,2],[5,6]], [[8,1]], [[3,5]] ]
+      a.each do |name,group|
+        assert_equal names.shift, name
+        assert_equal data.shift, group.map { |r| r.to_a } 
+      end   
+    end
+  end
  
   class MyRecord < Ruport::Data::Record; end
   

data/test/html_formatter_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w  
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestRenderHTMLTable < Test::Unit::TestCase
   
@@ -30,7 +31,29 @@ class TestRenderHTMLTable < Test::Unit::TestCase
       "\n\t\t\t<td>4</td>\n\t\t\t<td>5</td>\n\t\t\t<td>6</td>\n\t"+
       "\t</tr>\n\t</table>",actual)   
     
-  end   
+  end
+  
+  def test_render_with_template
+    Ruport::Formatter::Template.create(:simple) do |t|
+      t.table_format = {
+        :show_headings  => false
+      }
+      t.grouping_format = {
+        :style          => :justified,
+        :show_headings  => false
+      }
+    end
+
+    formatter = Ruport::Formatter::HTML.new
+    formatter.options = Ruport::Renderer::Options.new
+    formatter.options.template = :simple
+    formatter.apply_template
+    
+    assert_equal false, formatter.options.show_table_headers
+
+    assert_equal :justified, formatter.options.style
+    assert_equal false, formatter.options.show_group_headers
+  end
 end
    
 

data/test/pdf_formatter_test.rb

@@ -1,4 +1,5 @@
-require "test/helpers"
+#!/usr/bin/env ruby -w
+require File.join(File.expand_path(File.dirname(__FILE__)), "helpers")
 
 class TestRenderPDFTable < Test::Unit::TestCase
 
@@ -17,7 +18,8 @@ class TestRenderPDFTable < Test::Unit::TestCase
                               
   # this is mostly to check that the transaction hack gets called
   def test_relatively_large_pdf
-     table = Table("test/samples/dates.csv")  
+     table = Table(File.join(File.expand_path(File.dirname(__FILE__)), 
+                   %w[samples dates.csv]))  
      table.reduce(0..99)
      assert_nothing_raised { table.to_pdf }
   end 
@@ -32,6 +34,59 @@ class TestRenderPDFTable < Test::Unit::TestCase
     end
   end
   
+  def test_render_with_template
+    Ruport::Formatter::Template.create(:simple) do |t|
+      t.page_format = {
+        :size   => "LETTER",
+        :layout => :landscape
+      }
+      t.text_format = {
+        :font_size => 16
+      }
+      t.table_format = {
+        :show_headings  => false
+      }
+      t.column_format = {
+        :alignment  => :center,
+        :width      => 50
+      }
+      t.heading_format = {
+        :alignment  => :right,
+        :bold       => false,
+        :title      => "Test"
+      }
+      t.grouping_format = {
+        :style => :separated
+      }
+    end
+
+    formatter = Ruport::Formatter::PDF.new
+    formatter.options = Ruport::Renderer::Options.new
+    formatter.options.template = :simple
+    formatter.apply_template
+    
+    assert_equal "LETTER", formatter.options.paper_size
+    assert_equal :landscape, formatter.options.paper_orientation
+
+    assert_equal 16, formatter.options.text_format[:font_size]
+
+    assert_equal false, formatter.options.table_format[:show_headings]
+
+    assert_equal :center,
+      formatter.options.table_format[:column_options][:justification]
+    assert_equal 50,
+      formatter.options.table_format[:column_options][:width]
+      
+    assert_equal :right,
+      formatter.options.table_format[:column_options][:heading][:justification]
+    assert_equal false,
+      formatter.options.table_format[:column_options][:heading][:bold]
+    assert_equal "Test",
+      formatter.options.table_format[:column_options][:heading][:title]
+
+    assert_equal :separated, formatter.options.style
+  end
+  
   #--------BUG TRAPS--------#
   
   # PDF::SimpleTable does not handle symbols as column names
@@ -146,4 +201,15 @@ class TestPDFFormatterHelpers < Test::Unit::TestCase
     
     assert_equal 80, a.cursor        
   end
-end
+  
+  def test_draw_text_retains_cursor
+    a = Ruport::Formatter::PDF.new
+    a.move_cursor_to(100)
+    
+    a.draw_text "foo", :left => a.left_boundary
+    assert_equal 100, a.cursor
+    
+    a.draw_text "foo", :left => a.left_boundary + 50, :y => 500
+    assert_equal 100, a.cursor
+  end
+end