ruport 0.4.13 → 0.4.15

data/test/tc_format_engine.rb

@@ -10,11 +10,22 @@ class MockPlugin < Ruport::Format::Plugin
   
   renderer(:document) { data }
 
-  register_on :table_engine
-  register_on :document_engine
-
   rendering_options :red_cloth_enabled => true, 
                     :erb_enabled => true
+  
+  action(:reverse_data) { data.reverse }
+  action(:mock_action)  { "mock" }
+
+  helper(:test) { |eng| eng }
+
+  attribute :apple
+
+  helper(:complex_test) { |eng|
+    eng.rewrite_column(0) { "a" } if apple 
+  }
+
+  register_on :table_engine
+  register_on :document_engine
 
 end
 
@@ -25,13 +36,36 @@ class TestTabularFormatEngine < Test::Unit::TestCase
   def setup
     @engine = Format::Engine::Table.dup
   end
-  
+
+  def test_plugin_attributes
+    assert_equal nil, @engine.active_plugin.apple
+    @engine.active_plugin.apple = :banana
+    assert_equal :banana, @engine.active_plugin.apple
+  end
   def test_basic_render
      @engine.plugin = :mock
      @engine.data = [[1,2,3],[4,5,6],[7,8,9]]
      assert_equal( "#{@engine.data}", @engine.render )
   end
 
+  def test_plugin_actions
+    @engine.plugin = :mock
+    @engine.data = [1,2,3,4]
+    assert_equal( [4,3,2,1], @engine.active_plugin.reverse_data )
+    assert_equal( "mock", @engine.active_plugin.mock_action )
+  end
+
+  def test_helper
+    @engine.plugin = :mock
+    assert_equal @engine, @engine.test
+    @engine.data = [[1,2,3],[4,5,6]]
+    @engine.complex_test
+    assert_equal([[1,2,3],[4,5,6]],@engine.data)
+    @engine.active_plugin.apple = true
+    @engine.complex_test
+    assert_equal([['a',2,3],['a',5,6]],@engine.data)
+  end
+
   def test_render_without_field_names
     @engine.plugin = :mock
     @engine.show_field_names = false
@@ -68,7 +102,63 @@ class TestTabularFormatEngine < Test::Unit::TestCase
     @engine.data = [[1,2,3],[4,5,6]].to_ds(%w[a b c])
     assert_equal(3,@engine.num_cols)
   end
+
+  def test_plugin_access
+    @engine.plugin = :mock
+    @engine.data   = [[1,5],[3,8]]
+
+    #normal access
+    assert_equal :mock, @engine.active_plugin.plugin_name
+    assert_equal [[1,5],[3,8]], @engine.active_plugin.data
+
+    #block access
+    @engine.active_plugin do |p|
+      assert_equal :mock, p.plugin_name
+      assert_equal [[1,5],[3,8]], p.data
+    end
+  end
+
+  def test_prune
+    @engine.plugin = :mock
+    @engine.data = [[1,2,3],[1,4,3],[2,4,1]]
+    @engine.prune
+    assert_equal([[1,2,3],[nil,4,3],[2,4,1]],@engine.data)
+    @engine.data = [[1,2,3],[2,4,1],[2,7,9],[1,2,3],[1,7,9]]
+    @engine.prune
+    assert_equal([[1,2,3],[2,4,1],[nil,7,9],[1,2,3],[nil,7,9]],
+                 @engine.data)
+    @engine.data = [[1,2,3],[1,2,4],[1,3,7],[2,1,9],[2,2,3],[2,2,9]]
+    @engine.prune
+    assert_equal( [[1,2,3],[nil,nil,4],[nil,3,7],
+                   [2,1,9],[nil,2,3],[nil,nil,9]], @engine.data)
+     
+    @engine.data = [[1,2,3],[1,2,4],[1,3,7],[2,1,9],[2,2,3],[2,2,9]]
+    @engine.prune(1)
+    assert_equal( [[1,2,3],[nil,2,4],[nil,3,7],
+                   [2,1,9],[nil,2,3],[nil,2,9]], @engine.data)
+
+    data = DataSet.new %w[name date service amount]
+    data << [ "Greg Gibson", "1/1/2000",  "Prophy",  "100.00" ] <<
+            [ "Greg Gibson", "1/1/2000",  "Filling", "100.00" ] <<
+            [ "Greg Gibson", "1/12/2000", "Prophy",  "100.00" ] <<
+            [ "Greg Gibson", "1/12/2000", "Filling", "100.00" ] <<
+            [ "Greg Brown",  "1/12/2000", "Prophy",  "100.00" ]
+
+    @engine.data = data
+    @engine.prune(1)
+    data2 = data.dup
+    data2[1][0] = data2[2][0] = data2[3][0] = nil
+    assert_equal(data2, @engine.data)
     
+    @engine.data=data
+
+    data3 = data2.dup
+    data3[1][1] = data3[3][1] = nil
+    @engine.prune(2)
+
+    assert_equal(data3, @engine.data)
+  end
+
 end
 
 class TestDocumentFormatEngine < Test::Unit::TestCase

data/test/tc_record.rb

@@ -0,0 +1,140 @@
+require "test/unit"
+require "ruport"
+
+
+class RecordTest < Test::Unit::TestCase
+
+  include Ruport::Data
+
+  def setup
+    @attributes = %w[a b c d]
+    @record = Ruport::Data::Record.new [1,2,3,4], :attributes => @attributes 
+  end
+
+  def test_init
+    record = Ruport::Data::Record.new [1,2,3,4]
+    assert_equal 1, record[0]
+    assert_equal 2, record[1]
+    assert_equal 3, record[2]
+    assert_equal 4, record[3]
+
+    assert_equal 1, @record["a"]
+    assert_equal 4, @record["d"]
+    assert_equal 2, @record.b
+    assert_equal 3, @record.c
+
+  end
+  
+  def test_brackets
+    assert_equal 1, @record[0]
+    assert_equal 2, @record[1]
+    assert_equal 3, @record[2]
+    assert_equal 4, @record[3]
+
+    assert_equal 1, @record["a"]
+    assert_equal 2, @record["b"]
+    assert_equal 3, @record["c"]
+    assert_equal 4, @record["d"]
+  end
+  
+  def test_bracket_equals
+    @record[1] = "godzilla"
+    @record["d"] = "mothra"
+
+    assert_equal @record[1], "godzilla"
+    assert_equal @record["b"], "godzilla"
+
+    assert_equal @record[3], "mothra"
+    assert_equal @record["d"], "mothra"
+  end
+    
+  def test_accessors
+    assert_equal @record.a, @record["a"]
+    assert_equal @record.b, @record["b"]
+    assert_equal @record.c, @record["c"]
+    assert_equal @record.d, @record["d"]
+  end
+
+  def test_attribute_setting
+    @record.a = 10
+    @record.b = 20
+    assert_equal 10, @record.a
+    assert_equal 20, @record.b
+  end
+
+  def test_to_a
+    assert_equal [1,2,3,4], a = @record.to_a; a[0] = "q"
+    assert_equal [1,2,3,4], @record.to_a
+  end
+
+  def test_to_h
+    assert_nothing_raised { @record.to_h }
+    assert_equal({ "a" => 1, "b" => 2, "c" => 3, "d" => 4 }, @record.to_h)
+  end
+
+  def test_equality
+
+    dc  = %w[a b c d]
+    dc2 = %w[a b c d]
+    dc3 = %w[a b c]
+    
+    rec1 = Record.new [1,2,3,4]
+    rec2 = Record.new [1,2,3,4]
+    rec3 = Record.new [1,2]
+    rec4 = Record.new [1,2,3,4], :attributes => dc
+    rec5 = Record.new [1,2,3,4], :attributes => dc2
+    rec6 = Record.new [1,2,3,4], :attributes => dc3
+    rec7 = Record.new [1,2],     :attributes => dc
+    
+    [:==, :eql?].each do |op|
+      assert   rec1.send(op, rec2)
+      assert   rec4.send(op, rec5)
+      assert ! rec1.send(op,rec3)
+      assert ! rec1.send(op,rec4)
+      assert ! rec6.send(op,rec7)
+      assert ! rec3.send(op,rec4)
+    end
+
+  end
+
+  def test_attributes
+    assert_equal %w[a b c d], @record.attributes
+    @record.attributes = %w[apple banana courier django]
+    assert_equal %w[apple banana courier django], @record.attributes
+  end
+
+  def test_reordering
+    r = @record.reorder "a","d","b","c"
+    assert_equal [1,4,2,3], r.data
+    assert_equal %w[a d b c], r.attributes
+
+    assert_equal [1,2,3,4], @record.data
+    assert_equal %w[a b c d], @record.attributes
+    
+    @record.reorder! "a","d","b","c"
+    assert_equal [1,4,2,3], @record.data
+    assert_equal %w[a d b c], @record.attributes
+
+    @record.reorder! 3,1,2
+    assert_equal [3,4,2], @record.data
+    assert_equal %w[c d b], @record.attributes
+  end
+
+  def test_dup
+    rec1 = Record.new [1,2,3,4], :attributes => %w[a b c d]
+    rec2 = rec1.dup
+
+    rec2.a = 5
+    rec2["b"] = 7
+    rec2[2] = 9
+
+    rec2.tag(:apple)
+
+    assert_equal [1,2,3,4], rec1.data
+    assert_equal [5,7,9,4], rec2.data
+
+    assert_equal [], rec1.tags
+    assert_equal [:apple], rec2.tags
+  end
+
+end

data/test/tc_table.rb

@@ -0,0 +1,39 @@
+require "test/unit"
+require "ruport"
+
+class TestTable < Test::Unit::TestCase
+  def test_constructors
+    table = Ruport::Data::Table.new
+    table2 = Ruport::Data::Table.new :column_names => %w[a b c]
+    table3 = Ruport::Data::Table.new :data => [[1,2,3]]
+    table4 = Ruport::Data::Table.new :column_names => %w[col1 col2 col3], 
+                                     :data => [[1,2,3]]
+    tables = [table,table2,table3,table4]
+    tables.zip([nil,%w[a b c], nil, %w[col1 col2 col3]]).each do |t,n|
+      assert_equal n, t.column_names
+    end
+    
+    a = Ruport::Data::Record.new [1,2,3]
+    b = a.dup
+    b.attributes = %w[col1 col2 col3]
+    tables.zip([[],[],[a],[b]]).each { |t,n| assert_equal n, t.data }
+  end
+
+  def test_csv_load
+    table = Ruport::Data::Table.load("test/samples/data.csv")
+    assert_equal %w[col1 col2 col3], table.column_names
+    rows = [%w[a b c],["d",nil,"e"]]
+    table.each { |r| assert_equal rows.shift, r.data
+                     assert_equal %w[col1 col2 col3], r.attributes }
+  end
+
+  def test_reorder
+    table = Ruport::Data::Table.load("test/samples/data.csv")
+    table.reorder! *%w[col1 col3]
+    assert_equal %w[col1 col3], table.column_names
+    rows = [%w[a c], %w[d e]]
+    table.each { |r| assert_equal rows.shift, r.data
+                     assert_equal %w[col1 col3], r.attributes }
+  end
+
+end

data/test/tc_taggable.rb

@@ -0,0 +1,53 @@
+#!/usr/local/bin/ruby -w
+
+require "test/unit"
+require "ruport"
+
+class TestTaggable < Test::Unit::TestCase
+
+  include Ruport::Data
+  
+  def setup
+    @obj = Object.new.extend(Taggable)
+  end
+  
+  def test_tags_are_nil_initially
+    assert_equal nil, @obj.instance_variable_get(:@ruport_tags)
+  end
+  
+  def test_get_tags
+    @obj.instance_variable_set(:@ruport_tags, [:blue, :red])
+    assert_equal [:blue, :red], @obj.tags
+  end
+  
+  def test_set_tags
+    @obj.tags = [:orange, :yellow]
+    assert_equal [:orange, :yellow], @obj.instance_variable_get(:@ruport_tags)
+  end
+  
+  def test_tag
+    @obj.tag(:purple)
+    assert_equal [:purple], @obj.instance_variable_get(:@ruport_tags)
+  end
+  
+  def test_has_tag
+    @obj.tag(:maroon)
+    assert @obj.has_tag?(:maroon)
+  end
+  
+  def test_delete_tag
+    @obj.tag(:scarlet)
+    assert @obj.has_tag?(:scarlet)
+    @obj.delete_tag(:scarlet)
+    assert !@obj.has_tag?(:scarlet)
+  end
+
+  def test_avoid_duplication
+    @obj.tag(:smelly)
+    assert_equal 1, @obj.tags.select { |t| t.eql? :smelly }.length 
+    @obj.tag(:smelly)
+    assert_equal 1, @obj.tags.select { |t| t.eql? :smelly }.length   
+  end
+  
+end
+    

data/test/ts_all.rb

@@ -7,3 +7,6 @@ require "test/tc_config"
 require "test/tc_report"
 require "test/tc_data_set"
 require "test/tc_data_row"
+require "test/tc_taggable"
+require "test/tc_record"
+require "test/tc_table"