Spreadsheet-HTML 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74459c74abf314da4530023e49d8fe8215d4749b
-  data.tar.gz: 831d56fd9fa50caa9fde4549e299b0f12a8f0fe7
+  metadata.gz: 69280b7ae0534329c562340c5d86a9bc3753ca49
+  data.tar.gz: 86a46dc59fb742b0115aaf5d1f3feeb72d476934
 SHA512:
-  metadata.gz: 1ea3934540e350a44509d2f3cc7e8dc2c302b8d1c578464467a5cc781a502f750678d0a7d2f543b2c46ba936e8b8b8c97c8d66dc420cdbe77c976b5fae2455b8
-  data.tar.gz: 4b71690518be878ec820a4cc0349a29d2c5601d4fbd2ad9b814a3c518eb7ce80d3d737a9f954a1f8a896686e140cbfe4d230ae077c97129655224638bf5b967b
+  metadata.gz: 4aa64fa4375b280792b55d1a517598f9218be78ada368e1bef986dc1fbe42a6eb18c512341cdf9d456de727b6b0ab4e4da829f888217ea978f3fed58c48f84af
+  data.tar.gz: 67f8dc2ad38cd2544597471c28812e3ede9b21acd6e075e4f57b46470a9bf98966000685443f1da139160be298ef6f8f865883ebae837897e50b6a46eefd2751

data/Changes

@@ -1,5 +1,8 @@
 Revision history for html-autotag-ruby
 
+0.0.10
+    - implemented lambda/proc for dynamic and tag params
+
 0.0.9
     - implemented Dynamic Tags by headings
     - handle invalid fill params more gracefully

data/README

@@ -38,19 +38,25 @@ new( params )
     may be overriden in a subsequent call to a generator method (which are listed next).
 
 generate( params )
+    Generates an HTML table with headings positioned at the top.
+
 portrait( params )
+    Generates an HTML table with headings positioned at the top.
+
 north( params )
-    These three methods all generate an HTML table with headings positioned at the top.
+    Generates an HTML table with headings positioned at the top.
 
 landscape( params )
+    Generates an HTML table with headings positioned at the left.
+    
 west( params )
-    These two methods generate an HTML table with headings positioned at the left.
+    Generates an HTML table with headings positioned at the left.
     
 south( params )
-    This method generates an HTML table with headings positioned at the bottom.
+    Generates an HTML table with headings positioned at the bottom.
 
 east( params )
-    This method generates an HTML table with headings positioned at the right.
+    Generates an HTML table with headings positioned at the right.
 
 == Literal Parameters
     Literal Parameters provides the means to modify the macro aspects of the table,
@@ -59,100 +65,171 @@ east( params )
 data
     The data to be rendered as an HTML table. Array of Arrays.
 
+  'data' = > [ [ 1, 2, 3 ], [ 4, 5, 6 ], [7, 8, 9 ] ]
+
 tgroups
     Integer (0, 1 or 2). Group table rows into <thead>, <tbody> and <tfoot> sections.
     When tgroups is set to 1, the <tfoot> section is omitted. The last row of the data
     is found at the end of the <tbody> section instead. (loose) When tgroups is set to 2,
     the <tfoot> section is found in between the <thead> and <tbody> sections. (strict)
 
+  'tgroups' => 1
+  'tgroups' => 2
+
 indent
     The string to indent each row by. Defaults to undefined which produces no indentation.
     Automatically adds newlines when set to any defined value.
 
+  'indent' => '    '
+  'indent' => "\t"
+
 level
     Positive integer. The level to start indentation at. This is useful for matching the nesting styles of
     original HTML text that you may wish in insert into. (A value of 4 says "apply the repitition operator
     to the value of indent 4 times.)
 
+  'level' => 3
+
 empty
     String. Render any empty cells with this value. Defaults to &nbps; 
 
+  'empty' => ''
+
 encode
     Boolean. Whether or not to Encode entities.
 
+  'encode' => 1
+
 encodes
     String. Encode these HTML entities. Pass string with chars you want encoded
     or leave blank for default control and high bit chars and <>!'"
 
+  'encodes' => '<>'
+
 matrix
     Boolean. Render the headings row with only <td> tags, no <th> tags.
 
+  'matrix' => 1
+
 headless
     Boolean. Render the table without the headings row at all.
 
+  'headless' => 1
+
 theta
     Rotates table clockwise for positive values and counter-clockwise for negative values.
     Default is 0: headings at top. 90 yields headings at right, 180 yields headings at bottom.
-    270 yields headings at left. To achieve landscape, use -270.
+    270 yields headings at left. To achieve landscape, use -270 (or use the landscape() method).
+
+  'theta' => -270
 
 flip
     Flips the table horizontally from the perspective of the headings "row" by
     negating the value of theta.
 
+  'flip' => 1
+
 pinhead
     Works in conjunction with theta to ensure reporting readability. Without it, south() and east()
     would have data cells arranged in reverse order.
 
+  'pinhead' => 1
+
 fill
     Can be used instead of data to create a "blank" table or with data to pad rows and cells.
 
-  fill => '8x12' # 8 rows, 12 columns
+  'fill' => '8x12' # 8 rows, 12 columns
 
 == Dynamic Parameters
     Dynamic parameters provide a means to control the micro elements of the table,
     such as modifying headings by their name and rows and columns by their indices.
     They contain leading underscores to seperate them from literal and tag parameters.
+    They accepts Hashes for use as tag attributes, Procs or lambdas for altering the
+    CDATA of the cell, or Arrays that contain either (just like the 'td' and 'th' Tag
+    Parameters described below).
 
 _rX
-    Hash. Apply these attributes to row X (zero index based).
+    Apply these attributes to row X (zero index based).
+
+  '_r2' => { 'class' => 'third-row' }
+  '_r2' => lambda { |c| c.upcase }
+  '_r2' => [ lambda { |c| c.upcase }, { 'class' => 'third-row' } ]
 
 _cX
-    Hash. Apply these attributes to colum X (zero index based). You can also alias any
+    Apply these attributes to colum X (zero index based). You can also alias any
     column by the value of the heading name in that column prepended with underscore (_)
 
-  _occupation => { 'class' => 'foo' }
+  '_c4' => { 'class' => 'fifth-column' }
+  '_c4' => lambda { |c| c.upcase }
+  '_c4' => [ lambda { |c| c.upcase }, { 'class' => 'fifth-column' } ]
 
-  _salary => { 'class' => 'foo' }
+  '_occupation' => { 'class' => 'foo' }
+  '_salary' => lambda { |c| c.capitalize }
 
 _rXcY
-    Hash. Apply these attributes to colum Y in row X (zero index based).
+    Apply these attributes to colum Y in row X (zero index based).
+
+  '_r2c4' => { 'class' => 'third-row-fifth-column' }
+  '_r2c4' => lambda { |c| c.upcase }
+  '_r2c4' => [ lambda { |c| c.upcase }, { 'class' => 'third-row-fifth-column' } ]
 
 == Tag Parameters
     Tag Parameters provide a means to control the attributes of the table's tags, and in
-    the case of <th> and <td> the contents via callback subroutines (TODO!). Although
+    the case of <th> and <td> the contents via callback subroutines. Although
     similar in form, they are differentiated from litertal parameters because they share
     the names of the actual HTML table tags.
 
 table
+    Hash. Apply these attributes.
+
+  'table' => { 'class' => 'spreadsheet' }
+
 thead
+    Hash. Apply these attributes.
+
+  'thead' => { 'class' => 'headings' }
+
 tfoot
+    Hash. Apply these attributes.
+
+  'tfoot' => { 'class' => 'footings' }
+
 tbody
+    Hash. Apply these attributes.
+
+  'tbody' => { 'class' => 'bodyings' }
+
 tr
-    Hash. Apply these attributes to the specified tag.
+    Hash. Apply these attributes.
+
+  'tr => { 'class' => %w{ odd even } }
 
 th
+    <th> and <td> are the only Tag Parameters that also accept callback methods.
+
+  'th' => { 'style' => { 'color' => %w{ red green blue } } }
+  'th' => lambda { |c| c.upcase }
+  'th' => [ { 'style' => { 'color' => %w{ red green blue } }, lambda { |c| c.upcase } ]
+
 td
-    <th> and <td> will be the only Tag Parameters that accept callback methods, but this is still TODO.
-    In the meantime they behave the same as other Tag Parameters.
+    <th> and <td> are the only Tag Parameters that also accept callback methods.
+
+  'td' => { 'style' => { 'color' => %w{ red green blue } } }
+  'td' => lambda { |c| c.upcase }
+  'td' => [ { 'style' => { 'color' => %w{ red green blue } }, lambda { |c| c.upcase } ]
 
 thead.tr
     When tgroups is 1 or 2, this tag parameter is available to control the attributes of
     the <tr> tag within the <thead> group.
 
+  'thead.tr' => { 'class' => 'body-cell' }
+
 tfoot.tr
     When tgroups is 2, this tag parameter is available to control the attributes of
     the <tr> tag within the <tfoot> group.
 
+  'tbody.tr' => { 'class' => 'body-cell' }
+
 == License
     MIT
 

data/lib/Spreadsheet/HTML.rb

@@ -248,13 +248,13 @@ module Spreadsheet
             thingy.each do |t|
                 if t.kind_of?(Hash)
                     new_attr = t
-                #elsif t.kind_of?(Code)
-                #    puts "What now?"
+                elsif t.kind_of?(Proc)
+                    cdata = t.call( cdata )
                 end
             end
 
             attr = {}
-            orig_attr.each { |key,val| attr[key] = val }
+            orig_attr.each { |key,val| attr[key] = val } if orig_attr.kind_of?(Hash)
             new_attr.each  { |key,val| attr[key] = val }
 
             return [ cdata, attr ]

data/lib/Spreadsheet/HTML/version.rb

@@ -1,5 +1,5 @@
 module Spreadsheet
   class HTML
-    VERSION = "0.0.9"
+    VERSION = "0.0.10"
   end
 end

data/t/07-attrs.rb

@@ -92,6 +92,7 @@ class Test_Attributes < Test::Unit::TestCase
     )
 
   end 
+
   def test_th
 
     data = Array[
@@ -122,6 +123,126 @@ class Test_Attributes < Test::Unit::TestCase
 
   end 
 
+  def test_th_rotate
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th class="h1">header1</th><th class="h2">header2</th><th class="h3">header3</th><th class="h4">header4</th></tr><tr><td>foo1</td><td>bar1</td><td>baz1</td><td>qux1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td><td>qux2</td></tr><tr><td>foo3</td><td>bar3</td><td>baz3</td><td>qux3</td></tr><tr><td>foo4</td><td>bar4</td><td>baz4</td><td>qux4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'th' => { 'class' => %w{ h1 h2 h3 h4 } } ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'th' => { 'class' => %w{ h1 h2 h3 h4 } } ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'th' => { 'class' => %w{ h1 h2 h3 h4 } } ),
+        "via constructor and method"
+    )
+
+  end 
+
+  def test_th_lambda
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th>HEADER1</th><th>HEADER2</th><th>HEADER3</th><th>HEADER4</th></tr><tr><td>foo1</td><td>bar1</td><td>baz1</td><td>qux1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td><td>qux2</td></tr><tr><td>foo3</td><td>bar3</td><td>baz3</td><td>qux3</td></tr><tr><td>foo4</td><td>bar4</td><td>baz4</td><td>qux4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'th' => lambda { |c| c.upcase } ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'th' => lambda { |c| c.upcase } ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'th' => lambda { |c| c.upcase } ),
+        "via constructor and method"
+    )
+
+  end 
+
+  def test_th_proc
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th>HEADER1</th><th>HEADER2</th><th>HEADER3</th><th>HEADER4</th></tr><tr><td>foo1</td><td>bar1</td><td>baz1</td><td>qux1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td><td>qux2</td></tr><tr><td>foo3</td><td>bar3</td><td>baz3</td><td>qux3</td></tr><tr><td>foo4</td><td>bar4</td><td>baz4</td><td>qux4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'th' => Proc.new { |c| c.upcase } ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'th' => Proc.new { |c| c.upcase } ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'th' => Proc.new { |c| c.upcase } ),
+        "via constructor and method"
+    )
+
+  end 
+
+  def test_th_attr_and_lambda
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th style="color: red;">HEADER1</th><th style="color: green;">HEADER2</th><th style="color: blue;">HEADER3</th><th style="color: red;">HEADER4</th></tr><tr><td>foo1</td><td>bar1</td><td>baz1</td><td>qux1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td><td>qux2</td></tr><tr><td>foo3</td><td>bar3</td><td>baz3</td><td>qux3</td></tr><tr><td>foo4</td><td>bar4</td><td>baz4</td><td>qux4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'th' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'th' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'th' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ),
+        "via constructor and method"
+    )
+
+  end 
+
   def test_td
 
     data = Array[
@@ -182,6 +303,66 @@ class Test_Attributes < Test::Unit::TestCase
 
   end
 
+  def test_td_lambda
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th><th>header4</th></tr><tr><td>FOO1</td><td>BAR1</td><td>BAZ1</td><td>QUX1</td></tr><tr><td>FOO2</td><td>BAR2</td><td>BAZ2</td><td>QUX2</td></tr><tr><td>FOO3</td><td>BAR3</td><td>BAZ3</td><td>QUX3</td></tr><tr><td>FOO4</td><td>BAR4</td><td>BAZ4</td><td>QUX4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'td' => lambda { |c| c.upcase } ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'td' => lambda { |c| c.upcase } ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'td' => lambda { |c| c.upcase } ),
+        "via constructor and method"
+    )
+
+  end 
+
+  def test_td_attr_and_lambda
+
+    data = Array[
+        %w(header1 header2 header3 header4),
+        %w(foo1 bar1 baz1 qux1),
+        %w(foo2 bar2 baz2 qux2),
+        %w(foo3 bar3 baz3 qux3),
+        %w(foo4 bar4 baz4 qux4)
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th><th>header4</th></tr><tr><td style="color: red;">FOO1</td><td style="color: green;">BAR1</td><td style="color: blue;">BAZ1</td><td style="color: red;">QUX1</td></tr><tr><td style="color: green;">FOO2</td><td style="color: blue;">BAR2</td><td style="color: red;">BAZ2</td><td style="color: green;">QUX2</td></tr><tr><td style="color: blue;">FOO3</td><td style="color: red;">BAR3</td><td style="color: green;">BAZ3</td><td style="color: blue;">QUX3</td></tr><tr><td style="color: red;">FOO4</td><td style="color: green;">BAR4</td><td style="color: blue;">BAZ4</td><td style="color: red;">QUX4</td></tr></table>'
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, 'td' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ).generate(),
+        "via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, 'td' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ),
+        "via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( 'td' => [ lambda { |c| c.upcase }, { 'style' => { 'color' => %w{ red green blue } } } ] ),
+        "via constructor and method"
+    )
+
+  end 
+
   def test_headings
 
     data = Array[
@@ -230,7 +411,7 @@ class Test_Attributes < Test::Unit::TestCase
 
   end
 
-  def test_dynamic_params
+  def test_cX_attr
 
     data = Array[
         %w(header1 header2 header3),
@@ -243,19 +424,85 @@ class Test_Attributes < Test::Unit::TestCase
     assert_equal(
         html,
         Spreadsheet::HTML.new( 'data' => data, '_c1' => { 'style' => { 'color' => %w{ red green blue } } } ).generate(),
-        "_c1 via constructor only"
+        "_c1 attr via constructor only"
     )
     assert_equal(
         html,
         Spreadsheet::HTML.new().generate( 'data' => data, '_c1' => { 'style' => { 'color' => %w{ red green blue } } } ),
-        "_c1 via method only"
+        "_c1 attr via method only"
     )
     assert_equal(
         html,
         Spreadsheet::HTML.new( 'data' => data ).generate( '_c1' => { 'style' => { 'color' => %w{ red green blue } } } ),
-        "_c1 via constructor and method"
+        "_c1 attr via constructor and method"
+    )
+
+  end
+
+  def test_cX_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th>HEADER2</th><th>header3</th></tr><tr><td>foo1</td><td>BAR1</td><td>baz1</td></tr><tr><td>foo2</td><td>BAR2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_c1' => lambda { |c| c.upcase } ).generate(),
+        "_c1 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_c1' => lambda { |c| c.upcase } ),
+        "_c1 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_c1' => lambda { |c| c.upcase } ),
+        "_c1 attr via constructor and method"
+    )
+
+  end
+
+  def test_cX_attr_and_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th style="color: red;">HEADER2</th><th>header3</th></tr><tr><td>foo1</td><td style="color: green;">BAR1</td><td>baz1</td></tr><tr><td>foo2</td><td style="color: blue;">BAR2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_c1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ).generate(),
+        "_c1 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_c1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ),
+        "_c1 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_c1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ),
+        "_c1 attr via constructor and method"
     )
 
+  end
+
+  def test_rX_attr
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
     html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td style="color: red;">foo1</td><td style="color: green;">bar1</td><td style="color: blue;">baz1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
 
     assert_equal(
@@ -274,6 +521,72 @@ class Test_Attributes < Test::Unit::TestCase
         "_r1 via constructor and method"
     )
 
+  end
+
+  def test_rX_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td>FOO1</td><td>BAR1</td><td>BAZ1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_r1' => lambda { |c| c.upcase } ).generate(),
+        "_r1 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_r1' => lambda { |c| c.upcase } ),
+        "_r1 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_r1' => lambda { |c| c.upcase } ),
+        "_r1 attr via constructor and method"
+    )
+
+  end
+
+  def test_rX_attr_and_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td style="color: red;">FOO1</td><td style="color: green;">BAR1</td><td style="color: blue;">BAZ1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_r1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ).generate(),
+        "_r1 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_r1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ),
+        "_r1 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_r1' => [ { 'style' => { 'color' => %w{ red green blue } } }, lambda { |c| c.upcase } ] ),
+        "_r1 attr via constructor and method"
+    )
+
+  end
+
+  def test_rXcX_attr
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
     html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td>foo1</td><td>bar1</td><td style="color: red;">baz1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
 
     assert_equal(
@@ -294,4 +607,60 @@ class Test_Attributes < Test::Unit::TestCase
 
   end
 
+  def test_rXcX_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td>foo1</td><td>bar1</td><td>BAZ1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_r1c2' => lambda { |c| c.upcase } ).generate(),
+        "_r1c2 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_r1c2' => lambda { |c| c.upcase } ),
+        "_r1c2 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_r1c2' => lambda { |c| c.upcase } ),
+        "_r1c2 attr via constructor and method"
+    )
+
+  end
+
+  def test_rXcX_attr_and_lambda
+
+    data = Array[
+        %w(header1 header2 header3),
+        %w(foo1 bar1 baz1),
+        %w(foo2 bar2 baz2),
+    ]
+
+    html = '<table><tr><th>header1</th><th>header2</th><th>header3</th></tr><tr><td>foo1</td><td>bar1</td><td class="foo">BAZ1</td></tr><tr><td>foo2</td><td>bar2</td><td>baz2</td></tr></table>';
+
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data, '_r1c2' => [ { 'class' => 'foo' }, lambda { |c| c.upcase } ] ).generate(),
+        "_r1c2 attr via constructor only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new().generate( 'data' => data, '_r1c2' => [ { 'class' => 'foo' }, lambda { |c| c.upcase } ] ),
+        "_r1c2 attr via method only"
+    )
+    assert_equal(
+        html,
+        Spreadsheet::HTML.new( 'data' => data ).generate( '_r1c2' => [ { 'class' => 'foo' }, lambda { |c| c.upcase } ] ),
+        "_r1c2 attr via constructor and method"
+    )
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Spreadsheet-HTML
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - jeffa