prawn 1.0.0.rc1 → 1.0.0.rc2

data/spec/security_spec.rb

@@ -66,10 +66,10 @@ describe "Document encryption" do
         should == 0b1111_1111_1111_1111_1111_1111_1101_1111
     end
 
-    it "should raise ArgumentError if invalid option is provided" do
+    it "should raise_error ArgumentError if invalid option is provided" do
       lambda {
         doc_with_permissions(:modify_document => false)
-      }.should.raise(ArgumentError)
+      }.should raise_error(ArgumentError)
     end
 
   end
@@ -89,7 +89,7 @@ describe "Document encryption" do
     end
 
     it "should calculate the correct owner hash" do
-      @pdf.owner_password_hash.unpack("H*").first.should.match(/^61CA855012/i)
+      @pdf.owner_password_hash.unpack("H*").first.should match(/^61CA855012/i)
     end
 
     it "should calculate the correct user hash" do

data/spec/snapshot_spec.rb

@@ -76,7 +76,7 @@ describe "Prawn::Document#transaction" do
         rescue Prawn::Errors::CannotGroup
           add_lines(pdf)
         end
-      end.should.not.raise#(Prawn::Document::Snapshot::RollbackTransaction)
+      end.should_not raise_error#(Prawn::Document::Snapshot::RollbackTransaction)
     end
   end
 
@@ -141,7 +141,7 @@ describe "Prawn::Document#transaction" do
     Prawn::Document.new do |pdf|
       pdf.add_dest("dest", pdf.dest_fit_horizontally(pdf.cursor, pdf.page))
       pdf.text("Hello world")
-      lambda { pdf.transaction{} }.should.not.raise
+      lambda { pdf.transaction{} }.should_not raise_error
     end
   end
   
@@ -166,7 +166,7 @@ describe "Prawn::Document#transaction" do
           rollback
         end
       end
-      pdf.render.should.not =~ /\/Stamp1 Do/
+      pdf.render.should_not =~ /\/Stamp1 Do/
     end 
 
   end

data/spec/soft_mask_spec.rb

@@ -0,0 +1,117 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+module SoftMaskHelper
+  def make_soft_mask
+    @pdf.save_graphics_state do
+      @pdf.soft_mask do
+        if block_given?
+          yield
+        else
+          @pdf.fill_color '808080'
+          @pdf.fill_rectangle [100, 100], 200, 200
+        end
+      end
+
+      @pdf.fill_color '000000'
+      @pdf.fill_rectangle [0, 0], 200, 200
+    end
+  end
+end
+
+describe "Document with soft masks" do
+
+  include SoftMaskHelper
+
+  it "should have PDF version at least 1.4" do
+    create_pdf
+    make_soft_mask
+    str = @pdf.render
+    str[0,8].should == "%PDF-1.4"
+  end
+
+  it "should create a new extended graphics state for each unique soft mask" do
+    create_pdf
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [10, 10], 200, 200
+    end
+
+    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
+    extgstates.length.should == 2
+  end
+
+  it "a new extended graphics state should contain soft mask with drawing instructions" do
+    create_pdf
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    extgstate = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates.first
+    extgstate[:soft_mask][:G].data.should == "q\n/DeviceRGB cs\n0.000 0.000 0.000 scn\n/DeviceRGB CS\n0.000 0.000 0.000 SCN\n1 w\n0 J\n0 j\n[ ] 0 d\n/DeviceRGB cs\n0.502 0.502 0.502 scn\n100.000 -100.000 200.000 200.000 re\nf\nQ\n"
+  end
+
+  it "should not create duplicate extended graphics states" do
+    create_pdf
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    extgstates = PDF::Inspector::ExtGState.analyze(@pdf.render).extgstates
+    extgstates.length.should == 1
+  end
+
+  it "should not have objects that are not used for extended graphic state" do
+    @pdf = Prawn::Document.new(:margin => 0, :optimize_objects => true)
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    make_soft_mask do
+      @pdf.fill_color '808080'
+      @pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    reader = PDF::Reader.new(StringIO.open(@pdf.render))
+
+    groups = reader.objects.select { |obj|
+      o = obj[1]
+      o.is_a?(Hash) && o[:Type] == :Group
+    }
+    groups.length.should == 1
+
+    forms = reader.objects.select { |obj|
+      o = obj[1]
+      o.is_a?(PDF::Reader::Stream) && o.hash[:Type] == :XObject && o.hash[:Subtype] == :Form
+    }
+    forms.length.should == 1
+
+    masks = reader.objects.select { |obj|
+      o = obj[1]
+      o.is_a?(Hash) && o[:Type] == :Mask
+    }
+    masks.length.should == 1
+
+    ext_g_states = reader.objects.select { |obj|
+      o = obj[1]
+      o.is_a?(Hash) && o[:Type] == :ExtGState
+    }
+    ext_g_states.length.should == 1
+  end
+end

data/spec/span_spec.rb

@@ -4,22 +4,22 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "drawing span" do    
   
-  def setup
+  before do
     Prawn.debug = false
     create_pdf
   end
 
-  def teardown
+  after do
     Prawn.debug = true
   end
 
   it "should only accept :position as option in debug mode" do
     Prawn.debug = true
-    lambda { @pdf.span(350, {:x => 3}) {} }.should.raise(Prawn::Errors::UnknownOption)
+    lambda { @pdf.span(350, {:x => 3}) {} }.should raise_error(Prawn::Errors::UnknownOption)
   end
 
   it "should have raise an error if :position is invalid" do
-    lambda { @pdf.span(350, :position => :x) {} }.should.raise(ArgumentError)
+    lambda { @pdf.span(350, :position => :x) {} }.should raise_error(ArgumentError)
   end
 
   it "should restore the margin box when bounding box exits" do

data/spec/spec_helper.rb

@@ -2,7 +2,6 @@
 
 puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
 
-require "rubygems"
 require "bundler"
 Bundler.setup
 
@@ -11,11 +10,21 @@ require "prawn"
 
 Prawn.debug = true
 
-require "test/spec"
-require "mocha"
+#require "test/spec"
+require "rspec"
+require "mocha/api"
 require "pdf/reader"
 require "pdf/inspector"
 
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/extensions/ and its subdirectories.
+Dir[File.dirname(__FILE__) + "/extensions/**/*.rb"].each {|f| require f }
+
+RSpec.configure do |config|
+  config.mock_framework = :mocha
+  config.include EncodingHelpers
+end
+
 def create_pdf(klass=Prawn::Document)
   @pdf = klass.new(:margin => 0)
 end    
@@ -25,6 +34,3 @@ module Prawn::Graphics
   public :map_to_absolute
 end
 
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[extensions mocha]))
-

data/spec/stamp_spec.rb

@@ -7,7 +7,7 @@ describe "create_stamp before any page is added" do
       @pdf.create_stamp("my_stamp") do
         @pdf.font.height
       end
-    }.should.not.raise(Prawn::Errors::NotOnPage)
+    }.should_not raise_error(Prawn::Errors::NotOnPage)
   end
   it "should work with setting color" do
     @pdf = Prawn::Document.new(:skip_page_creation => true)
@@ -15,7 +15,7 @@ describe "create_stamp before any page is added" do
       @pdf.create_stamp("my_stamp") do
         @pdf.fill_color = 'ff0000'
       end
-    }.should.not.raise(Prawn::Errors::NotOnPage)
+    }.should_not raise_error(Prawn::Errors::NotOnPage)
   end
 end
 
@@ -33,21 +33,21 @@ describe "#stamp_at" do
 end
 
 describe "Document with a stamp" do
-  it "should raise NameTaken error when attempt to create stamp "+
+  it "should raise_error NameTaken error when attempt to create stamp "+
      "with same name as an existing stamp" do
     create_pdf
     @pdf.create_stamp("MyStamp")
     lambda {
       @pdf.create_stamp("MyStamp")
-    }.should.raise(Prawn::Errors::NameTaken)
+    }.should raise_error(Prawn::Errors::NameTaken)
   end
   
-  it "should raise InvalidName error when attempt to create "+
+  it "should raise_error InvalidName error when attempt to create "+
      "stamp with a blank name" do
     create_pdf
     lambda {
       @pdf.create_stamp("")
-    }.should.raise(Prawn::Errors::InvalidName)
+    }.should raise_error(Prawn::Errors::InvalidName)
   end
   
   it "a new XObject should be defined for each stamp created" do
@@ -63,12 +63,12 @@ describe "Document with a stamp" do
   end
 
   it "calling stamp with a name that does not match an existing stamp "+
-     "should raise UndefinedObjectName" do
+     "should raise_error UndefinedObjectName" do
     create_pdf
     @pdf.create_stamp("MyStamp")
     lambda {
       @pdf.stamp("OtherStamp")
-    }.should.raise(Prawn::Errors::UndefinedObjectName)
+    }.should raise_error(Prawn::Errors::UndefinedObjectName)
   end
 
   it "stamp should be drawn into the document each time stamp is called" do
@@ -99,7 +99,7 @@ describe "Document with a stamp" do
     objects = output.split("endobj")
     objects.each do |object|
       if object =~ /\/Type \/Page$/
-        object.should.not =~ /\/ExtGState/
+        object.should_not =~ /\/ExtGState/
       elsif object =~ /\/Type \/XObject$/
         object.should =~ /\/ExtGState/
       end
@@ -139,8 +139,8 @@ describe "Document with a stamp" do
     @pdf.stamp("MyStamp")
     stamps = PDF::Inspector::XObject.analyze(@pdf.render)
     stamp_stream = stamps.xobject_streams[:Stamp1].data
-    stamp_stream.should.include "/DeviceCMYK cs\n1.000 1.000 0.200 0.000 scn"
-    stamp_stream.should.include "/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN"
+    stamp_stream.should include("/DeviceCMYK cs\n1.000 1.000 0.200 0.000 scn")
+    stamp_stream.should include("/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN")
   end
   
   it "should save the color space even when same as current page color space" do
@@ -152,7 +152,7 @@ describe "Document with a stamp" do
     @pdf.stamp("MyStamp")
     stamps = PDF::Inspector::XObject.analyze(@pdf.render)
     stamp_stream = stamps.xobject_streams[:Stamp1].data
-    stamp_stream.should.include "/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN"
+    stamp_stream.should include("/DeviceCMYK CS\n1.000 1.000 0.200 0.000 SCN")
   end
     
 

data/spec/stroke_styles_spec.rb

@@ -12,8 +12,8 @@ describe "When stroking with default settings" do
     @pdf.join_style.should == :miter
   end
 
-  it "dashed? should be false" do
-    @pdf.should.not.be.dashed
+  it "dashed? should be_false" do
+    @pdf.should_not be_dashed
   end
 end
 
@@ -104,13 +104,13 @@ describe "Dashes" do
   
    it "should be able to use assignment operator" do
      @pdf.dash = 2
-     @pdf.should.be.dashed
+     @pdf.should be_dashed
   end
 
   describe "setting a dash" do
-    it "dashed? should be true" do
+    it "dashed? should be_true" do
       @pdf.dash(2)
-      @pdf.should.be.dashed
+      @pdf.should be_dashed
     end
     it "rendered PDF should include a stroked dash" do
       @pdf.dash(2)

data/spec/table_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 require 'set'
 
 describe "Prawn::Table" do
@@ -12,7 +12,7 @@ describe "Prawn::Table" do
     end
 
     it "should return a Prawn::Table" do
-      @table.should.be.an.instance_of Prawn::Table
+      @table.should be_a_kind_of Prawn::Table
     end
 
     it "should flatten the data into the @cells array in row-major order" do
@@ -29,17 +29,16 @@ describe "Prawn::Table" do
       lambda {
         data = [["foo","bar"],["baz",""]]
         @pdf.table(data)
-      }.should.not.raise
-    end   
+      }.should_not raise_error
+    end
 
     it "should allow a table with a header but no body" do
-      lambda { @pdf.table([["Header"]], :header => true) }.should.not.raise
+      lambda { @pdf.table([["Header"]], :header => true) }.should_not raise_error
     end
 
-    # TODO: pending colspan
-    xit "should accurately count columns from data" do
+    it "should accurately count columns from data" do
       # First data row may contain colspan which would hide true column count
-      data = [["Name:",{:text => "Some very long name", :colspan => 5}]]
+      data = [["Name:", {:content => "Some very long name", :colspan => 5}]]
       pdf = Prawn::Document.new
       table = Prawn::Table.new data, pdf
       table.column_widths.length.should == 6
@@ -56,7 +55,8 @@ describe "Prawn::Table" do
       initializer.expects(:kick).once
 
       @pdf.table([["a"]]){
-        self.should.be.an.instance_of(Prawn::Table); initializer.kick }
+        initializer.kick
+      }
     end
 
     it "should call a 1-arg block with the document as the argument" do
@@ -64,7 +64,7 @@ describe "Prawn::Table" do
       initializer.expects(:kick).once
 
       @pdf.table([["a"]]){ |doc|
-        doc.should.be.an.instance_of(Prawn::Table); initializer.kick }
+        doc.should be_a_kind_of(Prawn::Table); initializer.kick }
     end
 
     it "should proxy cell methods to #cells" do
@@ -80,7 +80,7 @@ describe "Prawn::Table" do
 
     it "should generate a text cell based on a String" do
       t = @pdf.table([["foo"]])
-      t.cells[0,0].should.be.a.kind_of(Prawn::Table::Cell::Text)
+      t.cells[0,0].should be_a_kind_of(Prawn::Table::Cell::Text)
     end
 
     it "should pass through a text cell" do
@@ -97,14 +97,14 @@ describe "Prawn::Table" do
     end
 
     it "should select rows by number or range" do
-      Set.new(@table.row(0).map { |c| c.content }).should == 
+      Set.new(@table.row(0).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R0C1])
-      Set.new(@table.rows(0..1).map { |c| c.content }).should == 
+      Set.new(@table.rows(0..1).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
     it "should select rows by array" do
-      Set.new(@table.rows([0, 1]).map { |c| c.content }).should == 
+      Set.new(@table.rows([0, 1]).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
@@ -118,14 +118,14 @@ describe "Prawn::Table" do
     end
 
     it "should select columns by number or range" do
-      Set.new(@table.column(0).map { |c| c.content }).should == 
+      Set.new(@table.column(0).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R1C0])
-      Set.new(@table.columns(0..1).map { |c| c.content }).should == 
+      Set.new(@table.columns(0..1).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
     it "should select columns by array" do
-      Set.new(@table.columns([0, 1]).map { |c| c.content }).should == 
+      Set.new(@table.columns([0, 1]).map { |c| c.content }).should ==
         Set.new(%w[R0C0 R0C1 R1C0 R1C1])
     end
 
@@ -143,13 +143,13 @@ describe "Prawn::Table" do
     end
 
     it "should accept a filter block, returning a cell proxy" do
-      @table.cells.filter { |c| c.content =~ /R0/ }.column(1).map{ |c| 
+      @table.cells.filter { |c| c.content =~ /R0/ }.column(1).map{ |c|
         c.content }.should == ["R0C1"]
     end
 
     it "should accept the [] method, returning a Cell or nil" do
       @table.cells[0, 0].content.should == "R0C0"
-      @table.cells[12, 12].should.be.nil
+      @table.cells[12, 12].should be_nil
     end
 
     it "should proxy unknown methods to the cells" do
@@ -160,6 +160,20 @@ describe "Prawn::Table" do
       @table.cells[1, 0].height.should == 100
     end
 
+    it "should ignore non-setter methods" do
+      lambda {
+        @table.cells.content_width
+      }.should raise_error(NoMethodError)
+    end
+
+    it "skips cells that don't respond to the given method" do
+      table = @pdf.make_table([[{:content => "R0", :colspan => 2}],
+                               %w[R1C0 R1C1]])
+      lambda {
+        table.row(0).font_style = :bold
+      }.should_not raise_error
+    end
+
     it "should accept the style method, proxying its calls to the cells" do
       @table.cells.style(:height => 200, :width => 200)
       @table.column(0).style(:width => 100)
@@ -204,14 +218,14 @@ describe "Prawn::Table" do
     end
 
     describe "width" do
-      it "should raise an error if the given width is outside of range" do
+      it "should raise_error an error if the given width is outside of range" do
         lambda do
           @pdf.table([["foo"]], :width => 1)
-        end.should.raise(Prawn::Errors::CannotFit)
+        end.should raise_error(Prawn::Errors::CannotFit)
 
         lambda do
           @pdf.table([[@long_text]], :width => @pdf.bounds.width + 100)
-        end.should.raise(Prawn::Errors::CannotFit)
+        end.should raise_error(Prawn::Errors::CannotFit)
       end
 
       it "should accept the natural width for small tables" do
@@ -220,7 +234,7 @@ describe "Prawn::Table" do
         @table.width.should == @table.cells[0, 0].natural_content_width + pad
       end
 
-      it "width should equal sum(column_widths)" do
+      it "width should == sum(column_widths)" do
         table = Prawn::Table.new([%w[ a b c ], %w[d e f]], @pdf) do
           column(0).width = 50
           column(1).width = 100
@@ -253,13 +267,13 @@ describe "Prawn::Table" do
          "column widths within a single table" do
         hpad, fs = 10, 6
         stretchy_columns = 2
-        
+
         col0_width = 50
         col1_width = @pdf.width_of("foo", :size => fs)
         col2_width = @pdf.width_of("foobar", :size => fs)
         col3_width = 150
 
-        table = Prawn::Table.new( [%w[snake foo b apple], 
+        table = Prawn::Table.new( [%w[snake foo b apple],
                                    %w[kitten d foobar banana]], @pdf,
           :cell_style => { :padding => hpad, :size => fs }) do
 
@@ -267,8 +281,8 @@ describe "Prawn::Table" do
           column(3).width = col3_width
         end
 
-        table.width.should == col1_width + col2_width + 
-                              2*stretchy_columns*hpad + 
+        table.width.should == col1_width + col2_width +
+                              2*stretchy_columns*hpad +
                               col0_width + col3_width
       end
 
@@ -277,7 +291,7 @@ describe "Prawn::Table" do
         col1_width = 20
         col3_width = 60
 
-        table = Prawn::Table.new( [["snake", "foo", "b", 
+        table = Prawn::Table.new( [["snake", "foo", "b",
                                       "some long, long text that will wrap"],
                                    %w[kitten d foobar banana]], @pdf,
                                  :width => 150) do
@@ -294,11 +308,11 @@ describe "Prawn::Table" do
         table.column(3).width.should == col3_width
       end
 
-      it "should not exceed the maximum width of the margin_box" do
+      it "should_not exceed the maximum width of the margin_box" do
         expected_width = @pdf.margin_box.width
         data = [
           ['This is a column with a lot of text that should comfortably exceed '+
-          'the width of a normal document margin_box width', 'Some more text', 
+          'the width of a normal document margin_box width', 'Some more text',
           'and then some more', 'Just a bit more to be extra sure']
         ]
         table = Prawn::Table.new(data, @pdf)
@@ -306,25 +320,25 @@ describe "Prawn::Table" do
         table.width.should == expected_width
       end
 
-      it "should not exceed the maximum width of the margin_box even with" +
+      it "should_not exceed the maximum width of the margin_box even with" +
         "manual widths specified" do
         expected_width = @pdf.margin_box.width
         data = [
           ['This is a column with a lot of text that should comfortably exceed '+
-          'the width of a normal document margin_box width', 'Some more text', 
+          'the width of a normal document margin_box width', 'Some more text',
           'and then some more', 'Just a bit more to be extra sure']
         ]
         table = Prawn::Table.new(data, @pdf) { column(1).width = 100 }
 
         table.width.should == expected_width
       end
-      
+
       it "scales down only the non-preset column widths when the natural width" +
         "exceeds the maximum width of the margin_box" do
         expected_width = @pdf.margin_box.width
         data = [
           ['This is a column with a lot of text that should comfortably exceed '+
-          'the width of a normal document margin_box width', 'Some more text', 
+          'the width of a normal document margin_box width', 'Some more text',
           'and then some more', 'Just a bit more to be extra sure']
         ]
         table = Prawn::Table.new(data, @pdf) { column(1).width = 100; column(3).width = 50 }
@@ -366,23 +380,23 @@ describe "Prawn::Table" do
             t.cells.size = 8
             t.cells.padding = 0
           end
-        end.should.not.raise(Prawn::Errors::CannotFit)
+        end.should_not raise_error(Prawn::Errors::CannotFit)
       end
 
       it "should be the width of the :width parameter" do
         expected_width = 300
-        table = Prawn::Table.new( [%w[snake foo b apple], 
+        table = Prawn::Table.new( [%w[snake foo b apple],
                                    %w[kitten d foobar banana]], @pdf,
                                  :width => expected_width)
 
         table.width.should == expected_width
       end
 
-      it "should not exceed the :width option" do
+      it "should_not exceed the :width option" do
         expected_width = 400
         data = [
           ['This is a column with a lot of text that should comfortably exceed '+
-          'the width of a normal document margin_box width', 'Some more text', 
+          'the width of a normal document margin_box width', 'Some more text',
           'and then some more', 'Just a bit more to be extra sure']
         ]
         table = Prawn::Table.new(data, @pdf, :width => expected_width)
@@ -390,11 +404,11 @@ describe "Prawn::Table" do
         table.width.should == expected_width
       end
 
-      it "should not exceed the :width option even with manual widths specified" do
+      it "should_not exceed the :width option even with manual widths specified" do
         expected_width = 400
         data = [
           ['This is a column with a lot of text that should comfortably exceed '+
-          'the width of a normal document margin_box width', 'Some more text', 
+          'the width of a normal document margin_box width', 'Some more text',
           'and then some more', 'Just a bit more to be extra sure']
         ]
         table = Prawn::Table.new(data, @pdf, :width => expected_width) do
@@ -404,25 +418,26 @@ describe "Prawn::Table" do
         table.width.should == expected_width
       end
 
-      # TODO: pending colspan
-      xit "should calculate unspecified column widths even " +
+      it "should calculate unspecified column widths even " +
          "with colspan cells declared" do
         pdf = Prawn::Document.new
         hpad, fs = 3, 5
         columns  = 3
 
-        data = [ [ { :text => 'foo', :colspan => 2 }, "foobar" ],
+        data = [ [ { :content => 'foo', :colspan => 2 }, "foobar" ],
                  [ "foo", "foo", "foo" ] ]
         table = Prawn::Table.new( data, pdf,
-          :horizontal_padding => hpad,
-          :font_size => fs )
+          :cell_style => {
+            :padding_left => hpad, :padding_right => hpad,
+            :size => fs
+          })
 
         col0_width = pdf.width_of("foo",    :size => fs) # cell 1, 0
         col1_width = pdf.width_of("foo",    :size => fs) # cell 1, 1
         col2_width = pdf.width_of("foobar", :size => fs) # cell 0, 1 (at col 2)
 
-        table.width.should == col0_width.ceil + col1_width.ceil +
-                              col2_width.ceil + 2*columns*hpad
+        table.width.should == col0_width + col1_width +
+                              col2_width + 2*columns*hpad
       end
     end
 
@@ -438,16 +453,16 @@ describe "Prawn::Table" do
         @pdf.y.should == old_y - table.height
       end
 
-      it "should not wrap unnecessarily" do
+      it "should_not wrap unnecessarily" do
         # Test for FP errors and glitches
         t = @pdf.table([["Bender Bending Rodriguez"]])
         h = @pdf.height_of("one line")
-        (t.height - 10).should.be < h*1.5
+        (t.height - 10).should be < h*1.5
       end
 
-      it "should have a height of n rows" do  
+      it "should have a height of n rows" do
         data = [["foo"],["bar"],["baaaz"]]
-           
+
         vpad = 4
         origin = @pdf.y
         @pdf.table data, :cell_style => { :padding => vpad }
@@ -457,8 +472,8 @@ describe "Prawn::Table" do
         line_gap = @pdf.font.line_gap
 
         num_rows = data.length
-        table_height.should.be.close(
-          num_rows * font_height + 2*vpad*num_rows, 0.001 )
+        table_height.should be_within(0.001).of(
+          num_rows * font_height + 2*vpad*num_rows )
       end
 
     end
@@ -491,10 +506,10 @@ describe "Prawn::Table" do
         @pdf.table([["foo"]], :column_widths => 500, :position => 123)
       end
 
-      it "should raise an ArgumentError on unknown :position" do
+      it "should raise_error an ArgumentError on unknown :position" do
         lambda do
           @pdf.table([["foo"]], :position => :bratwurst)
-        end.should.raise(ArgumentError)
+        end.should raise_error(ArgumentError)
       end
     end
 
@@ -516,7 +531,7 @@ describe "Prawn::Table" do
       end.page_count.should == 2
     end
 
-    it "should not start a new page before finishing out a row" do
+    it "should_not start a new page before finishing out a row" do
       Prawn::Document.new do
         table([[ (1..80).map{ |i| "Line #{i}" }.join("\n"), "Column 2" ]])
       end.page_count.should == 1
@@ -529,7 +544,7 @@ describe "Prawn::Table" do
       end.page_count.should == 2
     end
 
-    it "should not start a new page to gain height when at the top of " +
+    it "should_not start a new page to gain height when at the top of " +
        "a bounding box, even if stretchy" do
       Prawn::Document.new do
         bounding_box([bounds.left, bounds.top - 20], :width => 400) do
@@ -556,7 +571,7 @@ describe "Prawn::Table" do
 
       output = PDF::Inspector::Page.analyze(pdf.render)
       # Ensure we only drew the header once, on the second page
-      output.pages[0][:strings].should.be.empty
+      output.pages[0][:strings].should be_empty
       output.pages[1][:strings].should == ["Header", "Body"]
     end
 
@@ -590,6 +605,79 @@ describe "Prawn::Table" do
 
       t.draw
     end
+
+    describe "before_rendering_page callback" do
+      before(:each) { @pdf = Prawn::Document.new }
+
+      it "is passed all cells to be rendered on that page" do
+        kicked = 0
+
+        @pdf.table([["foo"]] * 100) do |t|
+          t.before_rendering_page do |page|
+            page.row_count.should == ((kicked < 3) ? 30 : 10)
+            page.column_count.should == 1
+            page.row(0).first.content.should == "foo"
+            page.row(-1).first.content.should == "foo"
+            kicked += 1
+          end
+        end
+
+        kicked.should == 4
+      end
+
+      it "numbers cells relative to their position on page" do
+        @pdf.table([["foo"]] * 100) do |t|
+          t.before_rendering_page do |page|
+            page[0, 0].content.should == "foo"
+          end
+        end
+      end
+
+      it "changing cells in the callback affects their rendering" do
+        seq = sequence("render order")
+
+        t = @pdf.make_table([["foo"]] * 40) do |table|
+          table.before_rendering_page do |page|
+            page[0, 0].background_color = "ff0000"
+          end
+        end
+
+        t.cells[30, 0].stubs(:draw_background).checking do |xy|
+          t.cells[30, 0].background_color.should == 'ff0000'
+        end
+        t.cells[31, 0].stubs(:draw_background).checking do |xy|
+          t.cells[31, 0].background_color.should == nil
+        end
+
+        t.draw
+      end
+
+      it "passes headers on page 2+" do
+        @pdf.table([["header"]] + [["foo"]] * 100, :header => true) do |t|
+          t.before_rendering_page do |page|
+            page[0, 0].content.should == "header"
+          end
+        end
+      end
+
+      it "allows headers to be changed" do
+        seq = sequence("render order")
+        @pdf.expects(:draw_text!).with { |t, _| t == "hdr1"}.in_sequence(seq)
+        @pdf.expects(:draw_text!).with { |t, _| t == "foo"}.times(29).in_sequence(seq)
+        # Verify that the changed cell doesn't mutate subsequent pages
+        @pdf.expects(:draw_text!).with { |t, _| t == "header"}.in_sequence(seq)
+        @pdf.expects(:draw_text!).with { |t, _| t == "foo"}.times(11).in_sequence(seq)
+
+        set_first_page_headers = false
+        @pdf.table([["header"]] + [["foo"]] * 40, :header => true) do |t|
+          t.before_rendering_page do |page|
+            # only change first page header
+            page[0, 0].content = "hdr1" unless set_first_page_headers
+            set_first_page_headers = true
+          end
+        end
+      end
+    end
   end
 
   describe "#style" do
@@ -610,7 +698,7 @@ describe "Prawn::Table" do
     it "should default to {} for the hash argument" do
       stylable = stub()
       stylable.expects(:style).with({}).once
-      
+
       Prawn::Document.new do
         table([["x"]]) { style(stylable) }
       end
@@ -628,16 +716,41 @@ describe "Prawn::Table" do
     it "should ignore headers" do
       data = [["header"], ["foo"], ["bar"], ["baz"]]
       pdf = Prawn::Document.new
-      t = pdf.table(data, :header => true, 
+      t = pdf.table(data, :header => true,
                     :row_colors => ['cccccc', 'ffffff']) do
         row(0).background_color = '333333'
       end
 
-      t.cells.map{|x| x.background_color}.should == 
+      t.cells.map{|x| x.background_color}.should ==
         %w[333333 cccccc ffffff cccccc]
     end
 
-    it "should not override an explicit background_color" do
+    it "stripes rows consistently from page to page, skipping header rows" do
+      data = [["header"]] + [["foo"]] * 70
+      pdf = Prawn::Document.new
+      t = pdf.make_table(data, :header => true,
+          :row_colors => ['cccccc', 'ffffff']) do
+        cells.padding = 0
+        cells.size = 9
+        row(0).size = 11
+      end
+
+      # page 1: header + 67 cells (odd number -- verifies that the next
+      # page disrupts the even/odd coloring, since both the last data cell
+      # on this page and the first one on the next are colored cccccc)
+      Prawn::Table::Cell.expects(:draw_cells).with do |cells|
+        cells.map { |c, (x, y)| c.background_color } ==
+          [nil] + (%w[cccccc ffffff] * 33) + %w[cccccc]
+      end
+      # page 2: header and 3 data cells
+      Prawn::Table::Cell.expects(:draw_cells).with do |cells|
+        cells.map { |c, (x, y)| c.background_color } ==
+          [nil] + %w[cccccc ffffff cccccc]
+      end
+      t.draw
+    end
+
+    it "should_not override an explicit background_color" do
       data = [["foo"], ["bar"], ["baz"]]
       pdf = Prawn::Document.new
       table = pdf.table(data, :row_colors => ['cccccc', 'ffffff']) { |t|
@@ -654,7 +767,7 @@ describe "Prawn::Table" do
 
     it "should set the x-position of each cell based on widths" do
       @table = @pdf.table([["foo", "bar", "baz"]])
-      
+
       x = 0
       (0..2).each do |col|
         cell = @table.cells[0, col]
@@ -669,7 +782,7 @@ describe "Prawn::Table" do
 
       (0..2).each do |row|
         cell = @table.cells[row, 0]
-        cell.y.should.be.close(y, 0.01)
+        cell.y.should be_within(0.01).of(y)
         y -= cell.height
       end
     end
@@ -682,16 +795,16 @@ describe "Prawn::Table" do
       output.strings.should == data.flatten
     end
 
-    it "should not cause an error if rendering the very first row causes a " +
+    it "should_not cause an error if rendering the very first row causes a " +
       "page break" do
-      Prawn::Document.new do
+      Prawn::Document.new do |pdf|
         arr = Array(1..5).collect{|i| ["cell #{i}"] }
 
-        move_down( y - (bounds.absolute_bottom + 3) )
+        pdf.move_down( pdf.y - (pdf.bounds.absolute_bottom + 3) )
 
         lambda {
-          table(arr)
-        }.should.not.raise
+          pdf.table(arr)
+        }.should_not raise_error
       end
     end
 
@@ -734,7 +847,7 @@ describe "Prawn::Table" do
     describe "in stretchy bounding boxes" do
       it "should draw all cells on a row at the same y-position" do
         pdf = Prawn::Document.new
-        
+
         text_y = pdf.y.to_i - 5 # text starts 5pt below current y pos (padding)
 
         pdf.bounding_box([0, pdf.cursor], :width => pdf.bounds.width) do
@@ -753,7 +866,7 @@ describe "Prawn::Table" do
       data = [["a", "b"], ["foo","bar"],["baz","bang"]]
       @pdf = Prawn::Document.new
       @pdf.table(data, :header => true)
-      output = PDF::Inspector::Text.analyze(@pdf.render)   
+      output = PDF::Inspector::Text.analyze(@pdf.render)
       output.strings.should == data.flatten
     end
 
@@ -762,16 +875,35 @@ describe "Prawn::Table" do
       headers = ["baz","foobar"]
       @pdf = Prawn::Document.new
       @pdf.table([headers] + data, :header => true)
-      output = PDF::Inspector::Text.analyze(@pdf.render)   
+      output = PDF::Inspector::Text.analyze(@pdf.render)
       output.strings.should == headers + data.flatten[0..-3] + headers +
         data.flatten[-2..-1]
     end
 
-    it "should not draw header twice when starting new page" do
+    it "draws headers at the correct position" do
+      data = [["header"]] + [["foo"]] * 40
+
+      Prawn::Table::Cell.expects(:draw_cells).times(2).checking do |cells|
+        cells.each do |cell, pt|
+          if cell.content == "header"
+            # Assert that header text is drawn at the same location on each page
+            if @header_location
+              pt.should == @header_location
+            else
+              @header_location = pt
+            end
+          end
+        end
+      end
+      @pdf = Prawn::Document.new
+      @pdf.table(data, :header => true)
+    end
+
+    it "should_not draw header twice when starting new page" do
       @pdf = Prawn::Document.new
       @pdf.y = 0
       @pdf.table([["Header"], ["Body"]], :header => true)
-      output = PDF::Inspector::Text.analyze(@pdf.render)   
+      output = PDF::Inspector::Text.analyze(@pdf.render)
       output.strings.should == ["Header", "Body"]
     end
   end
@@ -785,8 +917,8 @@ describe "Prawn::Table" do
 
     it "can be created from an Array" do
       cell = Prawn::Table::Cell.make(@pdf, [["foo"]])
-      cell.should.be.an.instance_of(Prawn::Table::Cell::Subtable)
-      cell.subtable.should.be.an.instance_of(Prawn::Table)
+      cell.should be_a_kind_of(Prawn::Table::Cell::Subtable)
+      cell.subtable.should be_a_kind_of(Prawn::Table)
     end
 
     it "defaults its padding to zero" do
@@ -796,7 +928,7 @@ describe "Prawn::Table" do
     it "has a subtable accessor" do
       @table.cells[0, 0].subtable.should == @subtable
     end
-    
+
     it "determines its dimensions from the subtable" do
       @table.cells[0, 0].width.should == @subtable.width
       @table.cells[0, 0].height.should == @subtable.height
@@ -805,35 +937,273 @@ describe "Prawn::Table" do
   end
 
   describe "An invalid table" do
-    
+
     before(:each) do
       @pdf = Prawn::Document.new
       @bad_data = ["Single Nested Array"]
     end
-    
-    it "should raise error when invalid table data is given" do
-      assert_raises(Prawn::Errors::InvalidTableData) do
+
+    it "should raise_error error when invalid table data is given" do
+      lambda {
         @pdf.table(@bad_data)
-      end
+      }.should raise_error(Prawn::Errors::InvalidTableData)
     end
 
-    it "should raise an EmptyTableError with empty table data" do
+    it "should raise_error an EmptyTableError with empty table data" do
       lambda {
         data = []
         @pdf = Prawn::Document.new
         @pdf.table(data)
-      }.should.raise( Prawn::Errors::EmptyTable )
-    end   
+      }.should raise_error( Prawn::Errors::EmptyTable )
+    end
 
-    it "should raise an EmptyTableError with nil table data" do
+    it "should raise_error an EmptyTableError with nil table data" do
       lambda {
         data = nil
         @pdf = Prawn::Document.new
         @pdf.table(data)
-      }.should.raise( Prawn::Errors::EmptyTable )
-    end   
+      }.should raise_error( Prawn::Errors::EmptyTable )
+    end
 
   end
 
 end
 
+describe "colspan / rowspan" do
+  before(:each) { create_pdf }
+
+  it "doesn't raise an error" do
+    lambda {
+      @pdf.table([[{:content => "foo", :colspan => 2, :rowspan => 2}]])
+    }.should_not raise_error
+  end
+
+  it "colspan is properly counted" do
+    t = @pdf.make_table([[{:content => "foo", :colspan => 2}]])
+    t.column_length.should == 2
+  end
+
+  it "rowspan is properly counted" do
+    t = @pdf.make_table([[{:content => "foo", :rowspan => 2}]])
+    t.row_length.should == 2
+  end
+
+  it "raises if colspan or rowspan are called after layout" do
+    lambda {
+      @pdf.table([["foo"]]) { cells[0, 0].colspan = 2 }
+    }.should raise_error(Prawn::Errors::InvalidTableSpan)
+
+    lambda {
+      @pdf.table([["foo"]]) { cells[0, 0].rowspan = 2 }
+    }.should raise_error(Prawn::Errors::InvalidTableSpan)
+  end
+
+  it "raises when spans overlap" do
+    lambda {
+      @pdf.table([["foo", {:content => "bar", :rowspan => 2}],
+                  [{:content => "baz", :colspan => 2}]])
+    }.should raise_error(Prawn::Errors::InvalidTableSpan)
+  end
+
+  it "table and cell width account for colspan" do
+    t = @pdf.table([["a", {:content => "b", :colspan => 2}]],
+                   :column_widths => [100, 100, 100])
+    spanned = t.cells[0, 1]
+    spanned.colspan.should == 2
+    t.width.should == 300
+    t.cells.min_width.should == 300
+    t.cells.max_width.should == 300
+    spanned.width.should == 200
+  end
+
+  it "table and cell height account for rowspan" do
+    t = @pdf.table([["a"], [{:content => "b", :rowspan => 2}]]) do
+      row(0..2).height = 100
+    end
+    spanned = t.cells[1, 0]
+    spanned.rowspan.should == 2
+    t.height.should == 300
+    spanned.height.should == 200
+  end
+
+  it "provides the full content_width as drawing space" do
+    w = @pdf.make_table([["foo"]]).cells[0, 0].content_width
+
+    t = @pdf.make_table([[{:content => "foo", :colspan => 2}]])
+    t.cells[0, 0].spanned_content_width.should == w
+  end
+
+  it "dummy cells are not drawn" do
+    # make a fake master cell for the dummy cell to slave to
+    t = @pdf.make_table([[{:content => "foo", :colspan => 2}]])
+
+    # drawing just a dummy cell should_not ink
+    @pdf.expects(:stroke_line).never
+    @pdf.expects(:draw_text!).never
+    Prawn::Table::Cell.draw_cells([t.cells[0, 1]])
+  end
+
+  it "dummy cells do not add any height or width" do
+    t1 = @pdf.table([["foo"]])
+
+    t2 = @pdf.table([[{:content => "foo", :colspan => 2}]])
+    t2.width.should == t1.width
+
+    t3 = @pdf.table([[{:content => "foo", :rowspan => 2}]])
+    t3.height.should == t1.height
+  end
+
+  it "dummy cells ignored by #style" do
+    t = @pdf.table([[{:content => "blah", :colspan => 2}]],
+                   :cell_style => { :size => 9 })
+    t.cells[0, 0].size.should == 9
+  end
+
+  context "inheriting master cell styles from dummy cell" do
+    # Relatively full coverage for all these attributes that should be
+    # inherited.
+    [["border_X_width", 20],
+     ["border_X_color", "123456"],
+     ["padding_X", 20]].each do |attribute, val|
+      attribute_right  = attribute.sub("X", "right")
+      attribute_left   = attribute.sub("X", "left")
+      attribute_bottom = attribute.sub("X", "bottom")
+      attribute_top    = attribute.sub("X", "top")
+
+      specify "#{attribute_right} of right column is inherited" do
+        t = @pdf.table([[{:content => "blah", :colspan => 2}]]) do |table|
+          table.column(1).send("#{attribute_right}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_right).should == val
+      end
+
+      specify "#{attribute_bottom} of bottom row is inherited" do
+        t = @pdf.table([[{:content => "blah", :rowspan => 2}]]) do |table|
+          table.row(1).send("#{attribute_bottom}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_bottom).should == val
+      end
+
+      specify "#{attribute_left} of right column is not inherited" do
+        t = @pdf.table([[{:content => "blah", :colspan => 2}]]) do |table|
+          table.column(1).send("#{attribute_left}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_left).should_not == val
+      end
+
+      specify "#{attribute_right} of interior column is not inherited" do
+        t = @pdf.table([[{:content => "blah", :colspan => 3}]]) do |table|
+          table.column(1).send("#{attribute_right}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_right).should_not == val
+      end
+
+      specify "#{attribute_bottom} of interior row is not inherited" do
+        t = @pdf.table([[{:content => "blah", :rowspan => 3}]]) do |table|
+          table.row(1).send("#{attribute_bottom}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_bottom).should_not == val
+      end
+
+      specify "#{attribute_top} of bottom row is not inherited" do
+        t = @pdf.table([[{:content => "blah", :rowspan => 2}]]) do |table|
+          table.row(1).send("#{attribute_top}=", val)
+        end
+
+        t.cells[0, 0].send(attribute_top).should_not == val
+      end
+    end
+  end
+
+  it "splits natural width between cols in the group" do
+    t = @pdf.table([[{:content => "foo", :colspan => 2}]])
+    widths = t.column_widths
+    widths[0].should == widths[1]
+  end
+
+  it "splits natural width between cols when width is increased" do
+    t = @pdf.table([[{:content => "foo", :colspan => 2}]],
+                   :width => @pdf.bounds.width)
+    widths = t.column_widths
+    widths[0].should == widths[1]
+  end
+
+  it "splits min-width between cols in the group" do
+    # Since column_widths, when reducing column widths, reduces proportional to
+    # the remaining width after each column's min width, we must ensure that the
+    # min-width is split proportionally in order to ensure the width is still
+    # split evenly when the width is reduced. (See "splits natural width between
+    # cols when width is reduced".)
+    t = @pdf.table([[{:content => "foo", :colspan => 2}]],
+                   :width => 20)
+    t.column(0).min_width.should == t.column(1).min_width
+  end
+
+  it "splits natural width between cols when width is reduced" do
+    t = @pdf.table([[{:content => "foo", :colspan => 2}]],
+                   :width => 20)
+    widths = t.column_widths
+    widths[0].should == widths[1]
+  end
+
+  it "honors a large, explicitly set table width" do
+    t = @pdf.table([[{:content => "AAAAAAAAAA", :colspan => 3}],
+                    ["A", "B", "C"]],
+                   :width => 400)
+
+    t.column_widths.inject(0) { |sum, w| sum + w }.
+      should be_within(0.01).of(400)
+  end
+
+  it "honors a small, explicitly set table width" do
+    t = @pdf.table([[{:content => "Lorem ipsum dolor sit amet " * 20,
+                      :colspan => 3}],
+                    ["A", "B", "C"]],
+                   :width => 200)
+
+    t.column_widths.inject(0) { |sum, w| sum + w }.
+      should be_within(0.01).of(200)
+  end
+
+  it "splits natural_content_height between rows in the group" do
+    t = @pdf.table([[{:content => "foo", :rowspan => 2}]])
+    heights = t.row_heights
+    heights[0].should == heights[1]
+  end
+
+  it "skips column numbers that have been col-spanned" do
+    t = @pdf.table([["a", "b", {:content => "c", :colspan => 3}, "d"]])
+    t.cells[0, 0].content.should == "a"
+    t.cells[0, 1].content.should == "b"
+    t.cells[0, 2].content.should == "c"
+    t.cells[0, 3].should be_a_kind_of(Prawn::Table::Cell::SpanDummy)
+    t.cells[0, 4].should be_a_kind_of(Prawn::Table::Cell::SpanDummy)
+    t.cells[0, 5].content.should == "d"
+  end
+
+  it "skips row/col positions that have been row-spanned" do
+    t = @pdf.table([["a", {:content => "b", :colspan => 2, :rowspan => 2}, "c"],
+                    ["d",                                                  "e"],
+                    ["f",               "g",              "h",             "i"]])
+    t.cells[0, 0].content.should == "a"
+    t.cells[0, 1].content.should == "b"
+    t.cells[0, 2].should be_a_kind_of(Prawn::Table::Cell::SpanDummy)
+    t.cells[0, 3].content.should == "c"
+
+    t.cells[1, 0].content.should == "d"
+    t.cells[1, 1].should be_a_kind_of(Prawn::Table::Cell::SpanDummy)
+    t.cells[1, 2].should be_a_kind_of(Prawn::Table::Cell::SpanDummy)
+    t.cells[1, 3].content.should == "e"
+
+    t.cells[2, 0].content.should == "f"
+    t.cells[2, 1].content.should == "g"
+    t.cells[2, 2].content.should == "h"
+    t.cells[2, 3].content.should == "i"
+  end
+end
+