prawn 1.0.0.rc2 → 1.0.0

data/spec/table/span_dummy_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "..", "spec_helper")
+require 'set'
+
+describe "Prawn::Table::Cell::SpanDummy" do
+  before(:each) do
+    @pdf = Prawn::Document.new
+    @table = @pdf.table([[{:content => "Row", :colspan => 2}]])
+    @master_cell = @table.cells[0,0]
+    @span_dummy  = @master_cell.dummy_cells.first
+  end
+
+  it "delegates background_color to the master cell" do
+    @span_dummy.background_color.should == @master_cell.background_color
+  end
+end

data/spec/table_spec.rb

@@ -45,6 +45,142 @@ describe "Prawn::Table" do
     end
   end
 
+  describe "You can explicitly set the column widths and use a colspan > 1" do
+
+    it "should tolerate floating point rounding errors < 0.000000001" do
+      data=[["a", "b ", "c ", "d", "e", "f", "g", "h", "i", "j", "k", "l"],
+            [{:content=>"Foobar", :colspan=>12}]
+          ]
+      #we need values with lots of decimals so that arithmetic errors will occur
+      #the values are not arbitrary but where found converting mm to pdf pt
+      column_widths=[137, 40, 40, 54.69291338582678, 54.69291338582678, 
+                     54.69291338582678, 54.69291338582678, 54.69291338582678, 
+                     54.69291338582678, 54.69291338582678, 54.69291338582678, 
+                     54.69291338582678]
+
+      pdf = Prawn::Document.new({:page_size => 'A4', :page_layout => :landscape})
+      table = Prawn::Table.new data, pdf, :column_widths => column_widths
+      table.column_widths.should == column_widths
+    end
+
+    it "should work with two different given colspans", :issue => 628 do 
+      data = [
+              [" ", " ", " "], 
+              [{:content=>" ", :colspan=>3}], 
+              [" ", {:content=>" ", :colspan=>2}]
+            ]
+      column_widths = [60, 240, 60]
+      pdf = Prawn::Document.new
+      #the next line raised an Prawn::Errors::CannotFit exception before issue 628 was fixed
+      table = Prawn::Table.new data, pdf, :column_widths => column_widths
+      table.column_widths.should == column_widths
+    end
+
+    it "should work with a colspan > 1 with given column_widths (issue #407)" do
+      #normal entries in line 1
+      data = [
+        [ '','',''],
+        [ { :content => "", :colspan => 3 } ],
+        [ "", "", "" ],
+      ]
+      pdf = Prawn::Document.new
+      table = Prawn::Table.new data, pdf, :column_widths => [100 , 200, 240]
+
+      #colspan entry in line 1
+      data = [
+        [ { :content => "", :colspan => 3 } ],
+        [ "", "", "" ],
+      ]
+      pdf = Prawn::Document.new
+      table = Prawn::Table.new data, pdf, :column_widths => [100 , 200, 240]
+
+      #mixed entries in line 1
+      data = [
+        [ { :content => "", :colspan =>2 }, "" ],
+        [ "", "", "" ],
+      ]
+      pdf = Prawn::Document.new
+      table = Prawn::Table.new data, pdf, :column_widths => [100 , 200, 240]
+
+      data = [['', '', {:content => '', :colspan => 2}, '',''],
+              ['',{:content => '', :colspan => 5}]
+              ]
+      pdf = Prawn::Document.new
+      table = Prawn::Table.new data, pdf, :column_widths => [50 , 100, 50, 50, 50, 50]
+
+    end
+
+    it "should not increase column width when rendering a subtable",
+       :unresolved, :issue => 612 do
+
+      pdf = Prawn::Document.new
+      
+      first = {:content=>"Foooo fo foooooo",:width=>50,:align=>:center}
+      second = {:content=>"Foooo",:colspan=>2,:width=>70,:align=>:center}
+      third = {:content=>"fooooooooooo, fooooooooooooo, fooo, foooooo fooooo",:width=>50,:align=>:center}
+      fourth = {:content=>"Bar",:width=>20,:align=>:center}
+      
+      table_content = [[
+      first,
+      [[second],[third,fourth]]
+      ]]
+      
+      table = Prawn::Table.new table_content, pdf
+      table.column_widths.should == [50.0, 70.0]
+    end
+
+    it "illustrate issue #533" do
+      data = [['', '', '', '', '',''],
+              ['',{:content => '', :colspan => 5}]]
+      pdf = Prawn::Document.new
+      table = Prawn::Table.new data, pdf, :column_widths => [50, 200, 40, 40, 50, 50]
+    end
+
+    it "illustrates issue #502" do
+      pdf = Prawn::Document.new
+      first = {:content=>"Foooo fo foooooo",:width=>50,:align=>:center}
+      second = {:content=>"Foooo",:colspan=>2,:width=>70,:align=>:center}
+      third = {:content=>"fooooooooooo, fooooooooooooo, fooo, foooooo fooooo",:width=>50,:align=>:center}
+      fourth = {:content=>"Bar",:width=>20,:align=>:center}
+      table_content = [[
+      first,
+      [[second],[third,fourth]]
+      ]]
+      pdf.move_down(20)
+      table = Prawn::Table.new table_content, pdf
+      pdf.table(table_content)
+    end
+
+    #https://github.com/prawnpdf/prawn/issues/407#issuecomment-28556698
+    it "correctly computes column widths with empty cells + colspan" do
+      data = [['', ''],
+              [{:content => '', :colspan => 2}]
+              ]
+      pdf = Prawn::Document.new
+
+      table = Prawn::Table.new data, pdf, :column_widths => [50, 200]
+      table.column_widths.should == [50.0, 200.0]
+    end
+
+    it "illustrates a variant of problem in issue #407 - comment 28556698" do 
+      pdf = Prawn::Document.new
+      table_data = [["a", "b", "c"], [{:content=>"d", :colspan=>3}]]
+      column_widths = [50, 60, 400]
+
+      # Before we fixed #407, this line incorrectly raise a CannotFit error
+      pdf.table(table_data, :column_widths => column_widths)
+    end
+
+    it "should not allow oversized subtables when parent column width is constrained" do
+      pdf = Prawn::Document.new
+      child_1 = pdf.make_table([['foo'*100]])
+      child_2 = pdf.make_table([['foo']])
+      lambda do
+        pdf.table([[child_1], [child_2]], column_widths: [pdf.bounds.width/2] * 2)
+      end.should raise_error(Prawn::Errors::CannotFit)
+    end
+  end
+
   describe "#initialize" do
     before(:each) do
       @pdf = Prawn::Document.new
@@ -374,13 +510,13 @@ describe "Prawn::Table" do
       end
 
       it "should allow table cells to be resized in block" do
-        lambda do
-          @pdf.table([%w[1 2 3 4 5]]) do |t|
-            t.width = 40
-            t.cells.size = 8
-            t.cells.padding = 0
-          end
-        end.should_not raise_error(Prawn::Errors::CannotFit)
+        # if anything goes wrong, a CannotFit error will be raised
+
+        @pdf.table([%w[1 2 3 4 5]]) do |t|
+          t.width = 40
+          t.cells.size = 8
+          t.cells.padding = 0
+        end
       end
 
       it "should be the width of the :width parameter" do
@@ -660,6 +796,17 @@ describe "Prawn::Table" do
         end
       end
 
+      it "updates dummy cell header rows" do
+        header = [[{:content => "header", :colspan => 2}]]
+        data   = [["foo", "bar"]] * 31
+        @pdf.table(header + data, :header => true) do |t|
+          t.before_rendering_page do |page|
+            cell = page[0, 0]
+            cell.dummy_cells.each {|dc| dc.row.should == cell.row }
+          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)
@@ -703,6 +850,12 @@ describe "Prawn::Table" do
         table([["x"]]) { style(stylable) }
       end
     end
+
+    it "ignores unknown values on a cell-by-cell basis" do
+      Prawn::Document.new do
+        table([["x", [["y"]]]], :cell_style => {:overflow => :shrink_to_fit})
+      end
+    end
   end
 
   describe "row_colors" do
@@ -862,49 +1015,123 @@ describe "Prawn::Table" do
   end
 
   describe "headers" do
-    it "should add headers to output when specified" 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.strings.should == data.flatten
-    end
+    context "single row header" do
+      it "should add headers to output when specified" 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.strings.should == data.flatten
+      end
 
-    it "should repeat headers across pages" do
-      data = [["foo","bar"]] * 30
-      headers = ["baz","foobar"]
-      @pdf = Prawn::Document.new
-      @pdf.table([headers] + data, :header => true)
-      output = PDF::Inspector::Text.analyze(@pdf.render)
-      output.strings.should == headers + data.flatten[0..-3] + headers +
-        data.flatten[-2..-1]
-    end
+      it "should repeat headers across pages" do
+        data = [["foo","bar"]] * 30
+        headers = ["baz","foobar"]
+        @pdf = Prawn::Document.new
+        @pdf.table([headers] + data, :header => true)
+        output = PDF::Inspector::Text.analyze(@pdf.render)
+        output.strings.should == headers + data.flatten[0..-3] + headers +
+          data.flatten[-2..-1]
+      end
 
-    it "draws headers at the correct position" do
-      data = [["header"]] + [["foo"]] * 40
+      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 "draws headers at the correct position with column box" 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
+        Prawn::Table::Cell.expects(:draw_cells).times(2).checking do |cells|
+          cells.each do |cell, pt|
+            if cell.content == "header"
+              pt[0].should == @pdf.bounds.left
             end
           end
         end
+        @pdf = Prawn::Document.new
+        @pdf.column_box [0, @pdf.cursor], :width => @pdf.bounds.width, :columns => 2 do
+            @pdf.table(data, :header => true)
+          end
+      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.strings.should == ["Header", "Body"]
       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.strings.should == ["Header", "Body"]
+    context "multiple row header" do
+      it "should add headers to output when specified" do
+        data = [["a", "b"], ["c", "d"], ["foo","bar"],["baz","bang"]]
+        @pdf = Prawn::Document.new
+        @pdf.table(data, :header => 2)
+        output = PDF::Inspector::Text.analyze(@pdf.render)
+        output.strings.should == data.flatten
+      end
+
+      it "should repeat headers across pages" do
+        data = [["foo","bar"]] * 30
+        headers = ["baz","foobar"] + ["bas", "foobaz"]
+        @pdf = Prawn::Document.new
+        @pdf.table([headers] + data, :header => 2)
+        output = PDF::Inspector::Text.analyze(@pdf.render)
+        output.strings.should == headers + data.flatten[0..-3] + headers +
+          data.flatten[-4..-1]
+      end
+
+      it "draws headers at the correct position" do
+        data = [["header"]] + [["header2"]] + [["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
+
+            if cell.content == "header2"
+              # Assert that header text is drawn at the same location on each page
+              if @header2_location
+                pt.should == @header2_location
+              else
+                @header2_location = pt
+              end
+            end
+          end
+        end
+        @pdf = Prawn::Document.new
+        @pdf.table(data, :header => 2)
+      end
+
+      it "should_not draw header twice when starting new page" do
+        @pdf = Prawn::Document.new
+        @pdf.y = 0
+        @pdf.table([["Header"], ["Header2"], ["Body"]], :header => 2)
+        output = PDF::Inspector::Text.analyze(@pdf.render)
+        output.strings.should == ["Header", "Header2", "Body"]
+      end
     end
   end
 
@@ -1165,7 +1392,6 @@ describe "colspan / rowspan" do
                       :colspan => 3}],
                     ["A", "B", "C"]],
                    :width => 200)
-
     t.column_widths.inject(0) { |sum, w| sum + w }.
       should be_within(0.01).of(200)
   end
@@ -1206,4 +1432,3 @@ describe "colspan / rowspan" do
     t.cells[2, 3].content.should == "i"
   end
 end
-

data/spec/text_at_spec.rb

@@ -98,32 +98,18 @@ describe "#draw_text" do
     text.strings.first.should == str
   end
 
-  if "spec".respond_to?(:encode!)
-    # Handle non utf-8 string encodings in a sane way on M17N aware VMs
-    it "should raise_error an exception when a utf-8 incompatible string is rendered" do
-      str = "Blah \xDD"
-      str.force_encoding("ASCII-8BIT")
-      lambda { @pdf.draw_text(str, :at => [0, 0]) }.should raise_error(
-        Prawn::Errors::IncompatibleStringEncoding)
-    end
-    it "should_not raise_error an exception when a shift-jis string is rendered" do
-      datafile = "#{Prawn::DATADIR}/shift_jis_text.txt"
-      sjis_str = File.open(datafile, "r:shift_jis") { |f| f.gets }
-      @pdf.font("#{Prawn::DATADIR}/fonts/gkai00mp.ttf")
-      lambda { @pdf.draw_text(sjis_str, :at => [0, 0]) }.should_not raise_error(
-        Prawn::Errors::IncompatibleStringEncoding)
-    end
-  else
-    # Handle non utf-8 string encodings in a sane way on non-M17N aware VMs
-    it "should raise_error an exception when a corrupt utf-8 string is rendered" do
-      str = "Blah \xDD"
-      lambda { @pdf.draw_text(str, :at => [0, 0]) }.should raise_error(
-        Prawn::Errors::IncompatibleStringEncoding)
-    end
-    it "should raise_error an exception when a shift-jis string is rendered" do
-      sjis_str = File.read("#{Prawn::DATADIR}/shift_jis_text.txt")
-      lambda { @pdf.draw_text(sjis_str, :at => [0, 0]) }.should raise_error(
-        Prawn::Errors::IncompatibleStringEncoding)
-    end
+  it "should raise_error an exception when a utf-8 incompatible string is rendered" do
+    str = "Blah \xDD"
+    str.force_encoding(Encoding::ASCII_8BIT)
+    lambda { @pdf.draw_text(str, :at => [0, 0]) }.should raise_error(
+      Prawn::Errors::IncompatibleStringEncoding)
+  end
+
+  it "should not raise an exception when a shift-jis string is rendered" do
+    datafile = "#{Prawn::DATADIR}/shift_jis_text.txt"
+    sjis_str = File.open(datafile, "r:shift_jis") { |f| f.gets }
+    @pdf.font("#{Prawn::DATADIR}/fonts/gkai00mp.ttf")
+
+    @pdf.draw_text(sjis_str, :at => [0, 0])
   end
 end

data/spec/text_box_spec.rb

@@ -116,7 +116,7 @@ describe "Text::Box" do
   end
   it "should default to document-wide leading if no" +
     "leading option is provided" do
-    
+
   end
 end
 
@@ -278,14 +278,15 @@ describe "Text::Box#render(:dry_run => true)" do
     text = PDF::Inspector::Text.analyze(@pdf.render)
     text.strings.should be_empty
   end
+
   it "subsequent calls to render should_not raise_error an ArgumentError exception" do
     create_pdf
     @text = "™©"
     @options = { :document => @pdf }
     text_box = Prawn::Text::Box.new(@text, @options)
     text_box.render(:dry_run => true)
-    lambda { text_box.render }.should_not raise_error(
-      Prawn::Errors::IncompatibleStringEncoding)
+
+    text_box.render
   end
 end
 
@@ -548,7 +549,7 @@ describe "Text::Box with text than can fit in the box" do
       :document => @pdf
     }
   end
-  
+
   it "printed text should match requested text, except that preceding and " +
     "trailing white space will be stripped from each line, and newlines may " +
     "be inserted" do
@@ -556,7 +557,7 @@ describe "Text::Box with text than can fit in the box" do
     text_box.render
     text_box.text.gsub("\n", " ").should == @text.strip
   end
-  
+
   it "render should return an empty string because no text remains unprinted" do
     text_box = Prawn::Text::Box.new(@text, @options)
     text_box.render.should == ""
@@ -582,7 +583,7 @@ describe "Text::Box with text that fits exactly in the box" do
       :document => @pdf
     }
   end
-  
+
   it "should have the expected height" do
     expected_height = @options.delete(:height)
     text_box = Prawn::Text::Box.new(@text, @options)
@@ -639,7 +640,7 @@ end
 
 describe "Text::Box printing UTF-8 string with higher bit characters" do
   before(:each) do
-    create_pdf    
+    create_pdf
     @text = "©"
     # not enough height to print any text, so we can directly compare against
     # the input string
@@ -648,28 +649,29 @@ describe "Text::Box printing UTF-8 string with higher bit characters" do
       :height => bounding_height,
       :document => @pdf
     }
-    file = "#{Prawn::DATADIR}/fonts/Action Man.dfont"
-    @pdf.font_families["Action Man"] = {
-      :normal      => { :file => file, :font => "ActionMan" },
-      :italic      => { :file => file, :font => "ActionMan-Italic" },
-      :bold        => { :file => file, :font => "ActionMan-Bold" },
-      :bold_italic => { :file => file, :font => "ActionMan-BoldItalic" }
+    file = "#{Prawn::DATADIR}/fonts/Panic+Sans.dfont"
+    @pdf.font_families["Panic Sans"] = {
+      :normal      => { :file => file, :font => "PanicSans" },
+      :italic      => { :file => file, :font => "PanicSans-Italic" },
+      :bold        => { :file => file, :font => "PanicSans-Bold" },
+      :bold_italic => { :file => file, :font => "PanicSans-BoldItalic" }
     }
     @text_box = Prawn::Text::Box.new(@text, options)
   end
   describe "when using a TTF font" do
     it "unprinted text should be in UTF-8 encoding" do
-      @pdf.font("Action Man")
+      @pdf.font("Panic Sans")
       remaining_text = @text_box.render
       remaining_text.should == @text
     end
+
     it "subsequent calls to Text::Box need not include the" +
        " :skip_encoding => true option" do
-      @pdf.font("Action Man")
+      @pdf.font("Panic Sans")
       remaining_text = @text_box.render
-      lambda {
-        @pdf.text_box(remaining_text, :document => @pdf)
-      }.should_not raise_error(Prawn::Errors::IncompatibleStringEncoding)
+
+      # expect that calling text_box will not raise an encoding error
+      @pdf.text_box(remaining_text, :document => @pdf)
     end
   end
 
@@ -684,17 +686,16 @@ describe "Text::Box printing UTF-8 string with higher bit characters" do
       lambda {
         @pdf.text_box(remaining_text, :document => @pdf)
       }.should raise_error(Prawn::Errors::IncompatibleStringEncoding)
-      lambda {
-        @pdf.text_box(remaining_text, :skip_encoding => true,
-                                      :document => @pdf)
-      }.should_not raise_error(Prawn::Errors::IncompatibleStringEncoding)
+
+      @pdf.text_box(remaining_text, :skip_encoding => true,
+                                    :document => @pdf)
     end
   end
 end
 
 describe "Text::Box with more text than can fit in the box" do
   before(:each) do
-    create_pdf    
+    create_pdf
     @text = "Oh hai text rect. " * 30
     @bounding_height = 162.0
     @options = {
@@ -703,7 +704,7 @@ describe "Text::Box with more text than can fit in the box" do
       :document => @pdf
     }
   end
-  
+
   context "truncated overflow" do
     before(:each) do
       @options[:overflow] = :truncate
@@ -741,7 +742,7 @@ describe "Text::Box with more text than can fit in the box" do
       end
     end
   end
-  
+
   context "truncated with text and size taken from the manual" do
     it "should return the right text" do
       @text = "This is the beginning of the text. It will be cut somewhere and " +
@@ -840,8 +841,8 @@ describe "Text::Box with a solid block of Chinese characters" do
 end
 
 
-describe "drawing bounding boxes" do    
-  before(:each) { create_pdf }   
+describe "drawing bounding boxes" do
+  before(:each) { create_pdf }
 
   it "should restore the margin box when bounding box exits" do
     margin_box = @pdf.bounds
@@ -876,7 +877,7 @@ describe "Text::Box#render with :character_spacing option" do
     text_box.text.should == "hello\nworld"
   end
 end
-  
+
 describe "Text::Box wrapping" do
   before(:each) do
     create_pdf
@@ -991,7 +992,7 @@ describe "Text::Box wrapping" do
 
     expected = "©" * 25 + "\n" + "©" * 5
     @pdf.font.normalize_encoding!(expected)
-    expected = expected.force_encoding("utf-8") if expected.respond_to?(:force_encoding)
+    expected = expected.force_encoding(Encoding::UTF_8)
     text_box.text.should == expected
   end
 
@@ -1008,7 +1009,7 @@ describe "Text::Box wrapping" do
     text_box.render
     results_without_accent = text_box.text
 
-    results_with_accent.first_line.length.should == results_without_accent.first_line.length
+    first_line(results_with_accent).length.should == first_line(results_without_accent).length
   end
 end
 
@@ -1027,3 +1028,7 @@ end
 def reduce_precision(float)
   ("%.5f" % float).to_f
 end
+
+def first_line(str)
+  str.each_line { |line| return line }
+end