ruport 0.11.0 → 0.12.0

data/test/csv_formatter_test.rb

@@ -5,72 +5,79 @@ begin
   require "rubygems"
 rescue LoadError
   nil
+end    
+
+class TestRenderCSVRow < Test::Unit::TestCase
+  def test_render_csv_row
+    actual = Ruport::Renderer::Row.render_csv(:data => [1,2,3])
+    assert_equal("1,2,3\n", actual)
+  end
 end
 
-class TestFormatCSV < Test::Unit::TestCase
+class TestRenderCSVTable < Test::Unit::TestCase
 
   def test_render_csv_table
-    actual = Ruport::Renderer::Table.render_csv { |r| 
+    actual = Ruport::Renderer::Table.render_csv do |r| 
       r.data = [[1,2,3],[4,5,6]].to_table 
-    }
+    end
     assert_equal("1,2,3\n4,5,6\n",actual)
 
-    actual = Ruport::Renderer::Table.render_csv { |r|
+    actual = Ruport::Renderer::Table.render_csv do |r|
       r.data = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    }
+    end
     assert_equal("a,b,c\n1,2,3\n4,5,6\n",actual)
+  end   
+  
+  def test_format_options
+    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    assert_equal "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
+      a.as(:csv,:format_options => { :col_sep => "\t" })
   end
 
+  def test_table_headers
+    actual = Ruport::Renderer::Table.
+             render_csv(:show_table_headers => false, 
+                        :data => [[1,2,3],[4,5,6]].to_table(%w[a b c]))
+    assert_equal("1,2,3\n4,5,6\n",actual)
+  end
+     
+end     
+
+class TestRenderCSVGroup < Test::Unit::TestCase
+
   def test_render_csv_group
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3],[4,5,6]],
                                     :column_names => %w[a b c])
-    actual = Ruport::Renderer::Group.render(:csv, :data => group,
-               :show_table_headers => false )
+    actual = Ruport::Renderer::Group.
+             render_csv(:data => group, :show_table_headers => false )
     assert_equal("test\n\n1,2,3\n4,5,6\n",actual)
-  end
+  end 
+  
+end
 
+class RenderCSVGrouping < Test::Unit::TestCase
   def test_render_csv_grouping
-    table = Table(%w[hi chris carter]) << %w[is this annoying] <<
+    table = Table(%w[hi red snapper]) << %w[is this annoying] <<
                                           %w[is it funny]
     grouping = Grouping(table,:by => "hi")
 
-    actual = grouping.to_csv #(:show_group_headers => false)
+    actual = grouping.to_csv
 
-    assert_equal "is\n\nchris,carter\nthis,annoying\nit,funny\n\n", actual
+    assert_equal "is\n\nred,snapper\nthis,annoying\nit,funny\n\n", actual
   end
 
   def test_render_csv_grouping_without_header
-    table = Table(%w[hi chris carter]) << %w[is this annoying] <<
+    table = Table(%w[hi red snapper]) << %w[is this annoying] <<
                                           %w[is it funny]
     grouping = Grouping(table,:by => "hi")
 
     actual = grouping.to_csv :show_table_headers => false
 
     assert_equal "is\n\nthis,annoying\nit,funny\n\n", actual
-  end
- 
-  def test_render_csv_row
-    actual = Ruport::Renderer::Row.render_csv { |r| r.data = [1,2,3] }
-    assert_equal("1,2,3\n", actual)
-  end
-
-  def test_format_options
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    assert_equal "a\tb\tc\n1\t2\t3\n4\t5\t6\n", 
-      a.as(:csv,:format_options => { :col_sep => "\t" })
-  end
-
-  def test_layout_header
-    actual = Ruport::Renderer::Table.render_csv { |r|
-      r.data = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-      r.options { |o| o.show_table_headers = false }
-    }
-    assert_equal("1,2,3\n4,5,6\n",actual)
   end  
 
   def test_alternative_styles
-
     g = Grouping((Table(%w[a b c]) << [1,2,3] << [1,1,4] <<
                                       [2,1,2] << [1,9,1] ), :by => "a")
     
@@ -81,7 +88,6 @@ class TestFormatCSV < Test::Unit::TestCase
 
     assert_equal "a,b,c\n1,2,3\n1,1,4\n1,9,1\n\n2,1,2\n\n",
                   g.to_csv(:style => :raw) 
-
   end
 
   # -----------------------------------------------------------------------
@@ -92,6 +98,4 @@ class TestFormatCSV < Test::Unit::TestCase
     g = Grouping((Table(%w[a b c])<<[1,2,3]<<[1,1,4]), :by => "a")
     assert_equal "1\n\nb,c\n2,3\n1,4\n\n", g.to_csv
   end
-
-
-end
+end

data/test/grouping_test.rb

@@ -4,6 +4,12 @@ begin; require "rubygems"; rescue LoadError; nil; end
 
 class TestGroup < Test::Unit::TestCase
 
+  def setup
+    @group = Ruport::Data::Group.new(:name => 'test',
+                                     :data => [[1,2,3]],
+                                     :column_names => %w[a b c])
+  end
+  
   def test_group_constructor
     group = Ruport::Data::Group.new(:name => 'test',
                                     :data => [[1,2,3]],
@@ -15,11 +21,8 @@ class TestGroup < Test::Unit::TestCase
   end
 
   def test_should_copy_group
-    group = Ruport::Data::Group.new(:name => 'test',
-                                    :data => [[1,2,3]],
-                                    :column_names => %w[a b c])
-    group.create_subgroups("a")
-    copy = group.dup
+    @group.create_subgroups("a")
+    copy = @group.dup
     assert_equal 'test', copy.name
     assert_equal Ruport::Data::Record.new([1,2,3],:attributes => %w[a b c]),
       copy.data[0]
@@ -31,73 +34,74 @@ class TestGroup < Test::Unit::TestCase
     assert_equal b, copy.subgroups
   end
 
-  def test_group_as
-    group = Ruport::Data::Group.new(:name => 'test',
-                                    :data => [%w[Ruport Is Sexy]],
-                                    :column_names => %w[Software Isnt Sexy])
-    assert_equal(7,group.to_text.to_a.length)
-    assert_equal(5,group.as(:text, :show_table_headers => false).to_a.length)
-    assert_equal(13,group.to_html.to_a.length)
-  end
-
   def test_eql
-    group = Ruport::Data::Group.new(:name => 'test',
-                                    :data => [%w[ruport is sexy]],
-                                    :column_names => %w[software isnt sexy])
-    table = [%w[ruport is sexy]].to_table(%w[software isnt sexy])
+    table = [[1,2,3]].to_table(%w[a b c])
 
     group2 = Ruport::Data::Group.new(:name => 'test',
-                                     :data => [%w[ruport is sexy]],
-                                     :column_names => %w[software isnt sexy])
+                                     :data => [[1,2,3]],
+                                     :column_names => %w[a b c])
 
-    assert_raises(NoMethodError) { group == table }
-    assert_equal group, group2
-    assert_equal group, group.dup
+    assert_raises(NoMethodError) { @group == table }
+    assert_equal @group, group2
+    assert_equal @group, @group.dup
   end
   
   def test_create_subgroups
-    group = Ruport::Data::Group.new(:name => 'test',
-                                    :data => [[1,2,3],[4,5,6]],
-                                    :column_names => %w[a b c])
+    group = @group << [4,5,6]
     group.create_subgroups("a")
     b = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
-                                  :column_names => %w[b c],
-                                  :name => 1 ),
+                                        :column_names => %w[b c],
+                                        :name => 1 ),
           4 => Ruport::Data::Group.new( :data => [[5,6]],
-                                  :column_names => %w[b c],
-                                  :name => 4 ) }
+                                        :column_names => %w[b c],
+                                        :name => 4 ) }
     assert_equal b, group.subgroups
+    
+    group.create_subgroups("b")
+    c = { 2 => Ruport::Data::Group.new( :data => [[3]],
+                                        :column_names => %w[c],
+                                        :name => 2 ) }
+    d = { 5 => Ruport::Data::Group.new( :data => [[6]],
+                                        :column_names => %w[c],
+                                        :name => 5 ) }
+    assert_equal c, group.subgroups[1].subgroups
+    assert_equal d, group.subgroups[4].subgroups
   end    
   
   def test_grouped_data
-    a = Group(nil, :data => [[1,2,3],[4,5,6]],
-              :column_names => %w[a b c]).send(:grouped_data, "a")
+    a = @group << [4,5,6]
     b = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
-                                  :column_names => %w[b c],
-                                  :name => 1 ),
+                                        :column_names => %w[b c],
+                                        :name => 1 ),
           4 => Ruport::Data::Group.new( :data => [[5,6]],
-                                  :column_names => %w[b c],
-                                  :name => 4 ) }
-    assert_equal b, a
+                                        :column_names => %w[b c],
+                                        :name => 4 ) }
+    assert_equal b, a.send(:grouped_data, "a")
   end
-  
-  def test_kernel_hack
-    expected = Ruport::Data::Group.new( :data => [[2,3]],
-                                  :column_names => %w[b c],
-                                  :name => 1 )
-    assert_equal expected, Group(1, :data => [[2,3]],
-                                    :column_names => %w[b c]) 
-  end      
+end
+
+class TestGroupRendering < Test::Unit::TestCase
 
+  def setup
+    @group = Ruport::Data::Group.new(:name => 'test',
+                                     :data => [[1,2,3]],
+                                     :column_names => %w[a b c])
+  end
+
+  def test_group_as
+    assert_equal(7, @group.to_text.to_a.length)
+    assert_equal(5, @group.as(:text,
+                              :show_table_headers => false).to_a.length)
+    assert_equal(13, @group.to_html.to_a.length)
+  end
+  
   def test_as_throws_proper_errors
-    group = Ruport::Data::Group.new(:name => 'test',
-                                    :data => [[1,2,3]],
-                                    :column_names => %w[a b c])
- 
-    assert_nothing_raised { group.as(:csv) }
-    assert_nothing_raised { group.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { group.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { group.to_nothing }
+    assert_nothing_raised { @group.as(:csv) }
+    assert_nothing_raised { @group.to_csv }
+    assert_raises(Ruport::Renderer::UnknownFormatError) {
+      @group.as(:nothing) }
+    assert_raises(Ruport::Renderer::UnknownFormatError) {
+      @group.to_nothing }
   end
 
   class MyGroupSub < Ruport::Data::Group; end
@@ -106,113 +110,83 @@ class TestGroup < Test::Unit::TestCase
     t = MyGroupSub.new(:column_names => %w[b c],:name => "1") << [2,3]
     assert_equal "1\n\nb,c\n2,3\n", t.to_csv
   end
- 
-  
 end
-
+    
 class TestGrouping < Test::Unit::TestCase
   
+  def setup
+    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    @grouping = Ruport::Data::Grouping.new(table, :by => "a")
+  end
+  
   def test_grouping_constructor
     a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
     b = Ruport::Data::Grouping.new(a, :by => "a")
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
-                                  :column_names => %w[b c],
-                                  :name => 1 ),
-         4 => Ruport::Data::Group.new( :data => [[5,6]],
-                                  :column_names => %w[b c],
-                                  :name => 4 ) }
+                                        :column_names => %w[b c],
+                                        :name => 1 ),
+          4 => Ruport::Data::Group.new( :data => [[5,6]],
+                                        :column_names => %w[b c],
+                                        :name => 4 ) }
     assert_equal c, b.data
   end      
   
-  def test_grouping_indexing   
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    b = Ruport::Data::Grouping.new(a, :by => "a")
-    c = [Ruport::Data::Group.new( :data => [[2,3]],
+  def test_grouping_indexing
+    a = [Ruport::Data::Group.new( :data => [[2,3]],
                                   :column_names => %w[b c],
                                   :name => 1 ),
          Ruport::Data::Group.new( :data => [[5,6]],
                                   :column_names => %w[b c],
-                                  :name => 4 ),    
+                                  :name => 4 ),
          Ruport::Data::Group.new( :data => [],
                                   :column_names => %w[b c],
                                   :name => 2)]
-    assert_equal c[0], b[1] 
-    assert_equal c[1], b[4]   
-    assert_raises(IndexError) { b[2] }                 
+    assert_equal a[0], @grouping[1]
+    assert_equal a[1], @grouping[4]
+    assert_raises(IndexError) { @grouping[2] }
   end    
   
   def test_should_copy_grouping
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    b = Ruport::Data::Grouping.new(a, :by => "a")
-    c = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
+    a = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
                                         :column_names => %w[b c],
                                         :name => 1 ),
           4 => Ruport::Data::Group.new( :data => [[5,6]],
                                         :column_names => %w[b c],
                                         :name => 4 ) }
-    copy = b.dup
-    assert_equal c, copy.data
+    copy = @grouping.dup
+    assert_equal a, copy.data
     assert_equal "a", copy.grouped_by
   end
 
   def test_append
    a =[[1,2,3],[4,5,6]].to_table(%w[a b c])
-   b = Ruport::Data::Grouping.new(a, :by => "a")
-   c = [Ruport::Data::Group.new( :data => [[2,3]],
-                                 :column_names => %w[b c],
-                                 :name => 1 ),
-        Ruport::Data::Group.new( :data => [[5,6]],
-                                 :column_names => %w[b c],
-                                 :name => 4 )]   
-   b << a.to_group("hand banana")
-   assert_equal b["hand banana"], a.to_group("hand banana")   
+   @grouping << a.to_group("red snapper")
+   assert_equal @grouping["red snapper"], a.to_group("red snapper")
    
-   assert_raises(ArgumentError) { b << a.to_group("hand banana") }   
-  end          
-  
-  def test_grouping_as
-    table = Ruport::Data::Table.new(:data => [%w[Ruport Is Sexy]],
-                                    :column_names => %w[Software Isnt Sexy])
-    grouping = Ruport::Data::Grouping.new(table, :by => 'Software')
-    assert_equal(8,grouping.to_text.to_a.length)
-    assert_equal(6,grouping.as(:text, :show_table_headers => false).to_a.length)
+   assert_raises(ArgumentError) { @grouping << a.to_group("red snapper") }
   end
-
+  
   def test_grouped_by
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    b = Grouping(a, :by => "a")
-    assert_equal "a", b.grouped_by
+    assert_equal "a", @grouping.grouped_by
   end
 
-  def test_kernel_hack
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    b = Grouping(a, :by => "a")
-    c = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
-                                  :column_names => %w[b c],
-                                  :name => 1 ),
-          4 => Ruport::Data::Group.new( :data => [[5,6]],
-                                  :column_names => %w[b c],
-                                  :name => 4 ) }
-    assert_equal c, b.data
-  end   
-
   def test_grouping_on_multiple_columns
     a = [[1,2,3,4],[4,5,6,7]].to_table(%w[a b c d])
     b = Ruport::Data::Grouping.new(a, :by => %w[a b c])
     c = { 1 => Ruport::Data::Group.new( :data => [[2,3,4]],
-                                  :column_names => %w[b c d],
-                                  :name => 1 ),
+                                        :column_names => %w[b c d],
+                                        :name => 1 ),
           4 => Ruport::Data::Group.new( :data => [[5,6,7]],
-                                  :column_names => %w[b c d],
-                                  :name => 4 ) }
+                                        :column_names => %w[b c d],
+                                        :name => 4 ) }
     assert_equal c, b.data
 
     d = { 2 => Ruport::Data::Group.new( :data => [[3,4]],
-                                  :column_names => %w[c d],
-                                  :name => 2 ) }
+                                        :column_names => %w[c d],
+                                        :name => 2 ) }
     e = { 5 => Ruport::Data::Group.new( :data => [[6,7]],
-                                  :column_names => %w[c d],
-                                  :name => 5 ) }
+                                        :column_names => %w[c d],
+                                        :name => 5 ) }
     assert_equal d, b[1].subgroups
     assert_equal e, b[4].subgroups
   end      
@@ -231,18 +205,6 @@ class TestGrouping < Test::Unit::TestCase
     assert_equal %w[schweet], sub.column("id")
   end
   
-  def test_as_throws_proper_errors
-
-    a = [[1,2,3],[4,5,6]].to_table(%w[a b c])
-    b = Grouping(a, :by => "a")
- 
- 
-    assert_nothing_raised { b.as(:csv) }
-    assert_nothing_raised { b.to_csv }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { b.as(:nothing) }
-    assert_raises(Ruport::Renderer::UnknownFormatError) { b.to_nothing }
-  end   
-  
   class TicketStatus < Ruport::Data::Record
 
     def closed
@@ -255,9 +217,8 @@ class TestGrouping < Test::Unit::TestCase
 
   end
   
-  def test_grouping_summary  
-
-    source = Table("test/samples/ticket_count.csv", 
+  def test_grouping_summary
+    source = Table("test/samples/ticket_count.csv",
                      :record_class => TicketStatus)
     grouping = Grouping(source,:by => "date")
     
@@ -266,14 +227,14 @@ class TestGrouping < Test::Unit::TestCase
       opened = group.sigma { |r| r.opened  }
       closed = group.sigma { |r| r.closed  }
       expected << { :date => date, :opened => opened, :closed => closed }
-    end       
+    end
     
     actual = grouping.summary :date,
       :opened => lambda { |g| g.sigma(:opened) },
       :closed => lambda { |g| g.sigma(:closed) },
       :order => [:date,:opened,:closed]
       
-    assert_equal expected, actual     
+    assert_equal expected, actual
     
     actual = grouping.summary :date,
       :opened => lambda { |g| g.sigma(:opened) },
@@ -282,6 +243,8 @@ class TestGrouping < Test::Unit::TestCase
     assert_equal [], expected.column_names - actual.column_names
   end   
  
+  class MyRecord < Ruport::Data::Record; end
+  
   def test_grouping_should_set_record_class
     a = Table(%w[a b c], :record_class => MyRecord) { |t| 
           t << [1,2,3]
@@ -298,8 +261,50 @@ class TestGrouping < Test::Unit::TestCase
     a = MyGroupingSub.new(t, :by => "a") 
     assert_equal "1\n\nb,c\n2,3\n\n", a.to_csv
   end
+end
+
+class TestGroupingRendering < Test::Unit::TestCase
+
+  def setup
+    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    @grouping = Ruport::Data::Grouping.new(table, :by => "a")
+  end
   
+  def test_grouping_as
+    assert_equal(16, @grouping.to_text.to_a.length)
+    assert_equal(12, @grouping.as(:text,
+      :show_table_headers => false).to_a.length)
+  end
+
+  def test_as_throws_proper_errors
+    assert_nothing_raised { @grouping.as(:csv) }
+    assert_nothing_raised { @grouping.to_csv }
+    assert_raises(Ruport::Renderer::UnknownFormatError) {
+      @grouping.as(:nothing) }
+    assert_raises(Ruport::Renderer::UnknownFormatError) {
+      @grouping.to_nothing }
+  end
 end
 
-class MyRecord < Ruport::Data::Record
+class TestGroupingKernelHacks < Test::Unit::TestCase
+
+  def test_group_kernel_hack
+    group = Ruport::Data::Group.new( :name => 'test',
+                                     :data => [[1,2,3]],
+                                     :column_names => %w[a b c])
+    assert_equal group, Group('test', :data => [[1,2,3]],
+                                      :column_names => %w[a b c]) 
+  end
+
+  def test_grouping_kernel_hack
+    table = [[1,2,3],[4,5,6]].to_table(%w[a b c])
+    grouping = Ruport::Data::Grouping.new(table, :by => "a")
+    a = { 1 => Ruport::Data::Group.new( :data => [[2,3]],
+                                        :column_names => %w[b c],
+                                        :name => 1 ),
+          4 => Ruport::Data::Group.new( :data => [[5,6]],
+                                        :column_names => %w[b c],
+                                        :name => 4 ) }
+    assert_equal a, grouping.data
+  end
 end