prawn 0.11.1 → 0.12.0

data/lib/prawn/document/bounding_box.rb

@@ -181,13 +181,20 @@ module Prawn
     private
 
     def init_bounding_box(user_block, options={}, &init_block)
+      unless user_block
+        raise ArgumentError,
+          "bounding boxes require a block to be drawn within the box"
+      end
+
       parent_box = @bounding_box
 
       init_block.call(parent_box)
 
       self.y = @bounding_box.absolute_top
       user_block.call
-      self.y = @bounding_box.absolute_bottom unless options[:hold_position]
+      unless options[:hold_position] || @bounding_box.stretchy?
+        self.y = @bounding_box.absolute_bottom
+      end
 
       created_box, @bounding_box = @bounding_box, parent_box
 
@@ -435,17 +442,23 @@ module Prawn
 
       # an alias for absolute_left
       def left_side
-         absolute_left
+        absolute_left
       end
 
       # an alias for absolute_right
       def right_side
-         absolute_right
+        absolute_right
       end
 
-      # starts a new page
+      # Moves to the top of the next page of the document, starting a new page
+      # if necessary.
+      #
       def move_past_bottom
-        @document.start_new_page
+        if @document.page_number == @document.page_count
+          @document.start_new_page
+        else
+          @document.go_to_page(@document.page_number + 1)
+        end
       end
 
 
@@ -458,6 +471,39 @@ module Prawn
         !@height
       end
 
+      # Returns the innermost non-stretchy bounding box.
+      #
+      def reference_bounds
+        if stretchy?
+          raise "Can't find reference bounds: my parent is unset" unless @parent
+          @parent.reference_bounds
+        else
+          self
+        end
+      end
+
+      # Returns a deep copy of these bounds (including all parent bounds but
+      # not copying the reference to the Document).
+      #
+      def deep_copy
+        copy = dup
+        # Deep-copy the parent bounds
+        copy.instance_variable_set("@parent", if BoundingBox === @parent
+                                                @parent.deep_copy
+                                              end)
+        copy.instance_variable_set("@document", nil)
+        copy
+      end
+
+      # Restores a copy of the bounds taken by BoundingBox.deep_copy in the
+      # context of the given +document+. Does *not* set the bounds of the
+      # document to the resulting BoundingBox, only returns it.
+      #
+      def self.restore_deep_copy(bounds, document)
+        bounds.instance_variable_set("@document", document)
+        bounds
+      end
+
     end
 
   end

data/lib/prawn/document/column_box.rb

@@ -41,25 +41,6 @@ module Prawn
       @bounding_box = parent_box
     end
     
-    # Template methods to support ColumnBox extensions
-    class BoundingBox
-      
-      # an alias for absolute_left
-      def left_side
-         absolute_left
-      end
-
-      # an alias for absolute_right
-      def right_side
-         absolute_right
-      end
-
-      # starts a new page
-      def move_past_bottom
-         @document.start_new_page
-      end
-    end
-
     # Implements the necessary functionality to allow Document#column_box to
     # work.
     #

data/lib/prawn/document/internals.rb

@@ -98,6 +98,7 @@ module Prawn
           go_to_page i
           state.page.new_content_stream
           apply_margin_options(options)
+          generate_margin_box
           use_graphic_settings(options[:template])
         end
       end

data/lib/prawn/document/snapshot.rb

@@ -51,6 +51,7 @@ module Prawn
         # between the old and new copies.
         {:page_content    => state.page.content.deep_copy,
          :current_page    => state.page.dictionary.deep_copy(share=[:Parent]),
+         :bounds          => bounds.deep_copy,
          :page_number     => page_number,
          :page_kids       => state.store.pages.data[:Kids].map{|kid| kid.identifier},
          :dests           => names? && 
@@ -77,6 +78,8 @@ module Prawn
         state.store.pages.data[:Kids] = shot[:page_kids].map{|id| state.store[id]}
         state.store.pages.data[:Count] = shot[:page_kids].size
 
+        self.bounds = BoundingBox.restore_deep_copy(shot[:bounds], self)
+
         if shot[:dests]
           names.data[:Dests] = shot[:dests] 
         end

data/lib/prawn/font.rb

@@ -52,7 +52,7 @@ module Prawn
         raise Prawn::Errors::NotOnPage 
       end
       
-      new_font = find_font(name, options)
+      new_font = find_font(name.to_s, options)
 
       if block_given?
         save_font do
@@ -179,7 +179,7 @@ module Prawn
     # custom ones, like :thin, and use them in font calls.
     #
     def font_families
-      @font_families ||= Hash.new { |h,k| h[k] = {} }.merge!(
+      @font_families ||= Hash.new.merge!(
         { "Courier"     => { :bold        => "Courier-Bold",
                              :italic      => "Courier-Oblique",
                              :bold_italic => "Courier-BoldOblique",
@@ -217,7 +217,8 @@ module Prawn
     # it and redefine the width calculation behavior.
     #++
     def width_of(string, options={})
-      font.compute_width_of(string, options) + character_spacing * string.length
+      font.compute_width_of(string, options) +
+        (character_spacing * font.character_count(string))
     end
   end
 

data/lib/prawn/font/afm.rb

@@ -94,6 +94,12 @@ module Prawn
           "Arguments to text methods must be UTF-8 encoded"
       end
 
+      # Returns the number of characters in +str+ (a WinAnsi-encoded string).
+      #
+      def character_count(str)
+        str.length
+      end
+
       # Perform any changes to the string that need to happen
       # before it is rendered to the canvas. Returns an array of
       # subset "chunks", where each chunk is an array of two elements.
@@ -210,8 +216,11 @@ module Prawn
       end
 
       def latin_kern_pairs_table
-        @kern_pairs_table ||= @kern_pairs.inject({}) do |h,p|
-          h[p[0].map { |n| Encoding::WinAnsi::CHARACTERS.index(n) }] = p[1]
+        return @kern_pairs_table if defined?(@kern_pairs_table)
+        
+        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
+        @kern_pairs_table = @kern_pairs.inject({}) do |h,p|
+          h[p[0].map { |n| character_hash[n] }] = p[1]
           h
         end
       end

data/lib/prawn/font/ttf.rb

@@ -190,6 +190,16 @@ module Prawn
         cmap[code] > 0
       end
 
+      # Returns the number of characters in +str+ (a UTF-8-encoded string).
+      #
+      def character_count(str)
+        if str.respond_to?(:encode)
+          str.length
+        else
+          str.unpack("U*").length
+        end
+      end
+
       private
 
       def cmap
@@ -233,6 +243,11 @@ module Prawn
 
       def character_width_by_code(code)    
         return 0 unless cmap[code]
+
+        # Some TTF fonts have nonzero widths for \n (UTF-8 / ASCII code: 10).
+        # Patch around this as we'll never be drawing a newline with a width.
+        return 0.0 if code == 10
+
         @char_widths[code] ||= Integer(hmtx.widths[cmap[code]] * scale_factor)
       end                   
 

data/lib/prawn/images.rb

@@ -158,7 +158,7 @@ module Prawn
     end 
     
     def overruns_page?(h)
-      (self.y - h) < bounds.absolute_bottom 
+      (self.y - h) < reference_bounds.absolute_bottom 
     end
 
     def calc_image_dimensions(info, options)

data/lib/prawn/table.rb

@@ -121,6 +121,7 @@ module Prawn
       @pdf = document
       @cells = make_cells(data)
       @header = false
+      @epsilon = 1e-9
       options.each { |k, v| send("#{k}=", v) }
 
       if block
@@ -168,7 +169,7 @@ module Prawn
       when Hash
         widths.each { |i, w| column(i).width = w }
       when Numeric
-        columns.width = widths
+        cells.width = widths
       else
         raise ArgumentError, "cannot interpret column widths"
       end
@@ -227,7 +228,7 @@ module Prawn
 
       # Reference bounds are the non-stretchy bounds used to decide when to
       # flow to a new column / page.
-      ref_bounds = @pdf.bounds.stretchy? ? @pdf.margin_box : @pdf.bounds
+      ref_bounds = @pdf.reference_bounds
 
       last_y = @pdf.y
 
@@ -258,9 +259,17 @@ module Prawn
         end
       end
 
+      # Track cells to be drawn on this page. They will all be drawn when this
+      # page is finished.
+      cells_this_page = []
+
       @cells.each do |cell|
         if cell.height > (cell.y + offset) - ref_bounds.absolute_bottom &&
            cell.row > started_new_page_at_row
+          # Ink all cells on the current page
+          Cell.draw_cells(cells_this_page)
+          cells_this_page = []
+
           # start a new page or column
           @pdf.bounds.move_past_bottom
           draw_header unless cell.row == 0
@@ -285,9 +294,11 @@ module Prawn
           cell.background_color = @row_colors[index % @row_colors.length]
         end
 
-        cell.draw([x, y])
+        cells_this_page << [cell, [x, y]]
         last_y = y
       end
+      # Draw the last page of cells
+      Cell.draw_cells(cells_this_page)
 
       @pdf.move_cursor_to(last_y - @cells.last.height)
     end
@@ -303,19 +314,19 @@ module Prawn
     #
     def column_widths
       @column_widths ||= begin
-        if width < cells.min_width
+        if width - cells.min_width < -epsilon
           raise Errors::CannotFit,
             "Table's width was set too small to contain its contents " +
             "(min width #{cells.min_width}, requested #{width})"
         end
 
-        if width > cells.max_width
+        if width - cells.max_width > epsilon
           raise Errors::CannotFit,
             "Table's width was set larger than its contents' maximum width " +
             "(max width #{cells.max_width}, requested #{width})"
         end
 
-        if width < natural_width
+        if width - natural_width < -epsilon
           # Shrink the table to fit the requested width.
           f = (width - cells.min_width).to_f / (natural_width - cells.min_width)
 
@@ -323,7 +334,7 @@ module Prawn
             min, nat = column(c).min_width, column(c).width
             (f * (nat - min)) + min
           end
-        elsif width > natural_width
+        elsif width - natural_width > epsilon
           # Expand the table to fit the requested width.
           f = (width - cells.width).to_f / (cells.max_width - cells.width)
 
@@ -447,6 +458,11 @@ module Prawn
       y_positions.each_with_index { |y, i| row(i).y = y }
     end
 
+    private
+
+    def epsilon
+      @epsilon
+    end
   end
 
 

data/lib/prawn/table/cell.rb

@@ -233,15 +233,39 @@ module Prawn
       # Draws the cell onto the document. Pass in a point [x,y] to override the
       # location at which the cell is drawn.
       #
+      # If drawing a group of cells at known positions, look into
+      # Cell.draw_cells, which ensures that the backgrounds, borders, and
+      # content are all drawn in correct order so as not to overlap.
+      #
       def draw(pt=[x, y])
-        set_width_constraints
+        self.class.draw_cells([[self, pt]])
+      end
+
+      # Given an array of pairs [cell, pt], draws each cell at its
+      # corresponding pt, making sure all backgrounds are behind all borders
+      # and content.
+      #
+      def self.draw_cells(cells)
+        cells.each do |cell, pt|
+          cell.set_width_constraints
+          cell.draw_background(pt)
+        end
 
-        draw_background(pt)
-        draw_borders(pt)
-        @pdf.bounding_box([pt[0] + padding_left, pt[1] - padding_top], 
-                          :width  => content_width + FPTolerance,
-                          :height => content_height + FPTolerance) do
-          draw_content
+        cells.each do |cell, pt|
+          cell.draw_borders(pt)
+          cell.draw_bounded_content(pt)
+        end
+      end
+
+      # Draws the cell's content at the point provided.
+      #
+      def draw_bounded_content(pt)
+        @pdf.float do
+          @pdf.bounding_box([pt[0] + padding_left, pt[1] - padding_top], 
+                            :width  => content_width + FPTolerance,
+                            :height => content_height + FPTolerance) do
+            draw_content
+          end
         end
       end
 
@@ -450,8 +474,6 @@ module Prawn
         @border_widths[3] = val
       end
 
-      protected
-
       # Sets the cell's minimum and maximum width. Deferred until requested
       # because padding and size can change.
       #

data/lib/prawn/table/cell/text.rb

@@ -74,8 +74,6 @@ module Prawn
           end
         end
 
-        protected
-
         def set_width_constraints
           # Sets a reasonable minimum width. If the cell has any content, make
           # sure we have enough width to be at least one character wide. This is
@@ -85,6 +83,8 @@ module Prawn
           super
         end
 
+        protected
+
         def with_font
           @pdf.save_font do
             options = {}

data/prawn.gemspec

@@ -1,5 +1,5 @@
 # Version numbering: http://wiki.github.com/sandal/prawn/development-roadmap
-PRAWN_VERSION = "0.11.1"
+PRAWN_VERSION = "0.12.0"
 
 Gem::Specification.new do |spec|
   spec.name = "prawn"
@@ -12,16 +12,15 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 1.8.7'
   spec.required_rubygems_version = ">= 1.3.6"
 
-  spec.test_files = Dir[ "test/*_test.rb" ]
-  spec.has_rdoc = true
-  spec.extra_rdoc_files = %w{HACKING README LICENSE COPYING}
+  spec.test_files = Dir[ "spec/*_spec.rb" ]
+  spec.extra_rdoc_files = %w{README.md LICENSE COPYING GPLv2 GPLv3}
   spec.rdoc_options << '--title' << 'Prawn Documentation' <<
                        '--main'  << 'README' << '-q'
-  spec.authors = ["Gregory Brown","Brad Ediger","Daniel Nelson","Jonathen Greenberg","James Healy"]
+  spec.authors = ["Gregory Brown","Brad Ediger","Daniel Nelson","Jonathan Greenberg","James Healy"]
   spec.email = ["gregory.t.brown@gmail.com","brad@bradediger.com","dnelson@bluejade.com","greenberg@entryway.net","jimmy@deefa.com"]
   spec.rubyforge_project = "prawn"
   spec.add_dependency('pdf-reader', '>=0.9.0')
-  spec.add_dependency('ttfunk', '~>1.0.0')
+  spec.add_dependency('ttfunk', '~>1.0.2')
   spec.homepage = "http://prawn.majesticseacreature.com"
   spec.description = <<END_DESC
   Prawn is a fast, tiny, and nimble PDF generator for Ruby

data/spec/bounding_box_spec.rb

@@ -87,6 +87,13 @@ describe "A bounding box" do
     end.should.raise(ArgumentError)
   end
 
+  it "should raise an ArgumentError if a block is not passed" do
+    pdf = Prawn::Document.new
+    lambda do
+      pdf.bounding_box([0, 0], :width => 200)
+    end.should.raise(ArgumentError)
+  end
+
 end
 
 describe "drawing bounding boxes" do
@@ -140,6 +147,44 @@ describe "drawing bounding boxes" do
     box.height.should == 100
   end
 
+  it "should advance the y-position by bbox.height by default" do
+    orig_y = @pdf.y
+    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width,
+        :height => 30 do
+      @pdf.text "hello"
+    end
+    @pdf.y.should.be.close(orig_y - 30, 0.001)
+  end
+
+  it "should not advance y-position if passed :hold_position => true" do
+    orig_y = @pdf.y
+    @pdf.bounding_box [0, @pdf.cursor], :width => @pdf.bounds.width,
+        :hold_position => true do
+      @pdf.text "hello"
+    end
+    # y only advances by height of one line ("hello")
+    @pdf.y.should.be.close(orig_y - @pdf.height_of("hello"), 0.001)
+  end
+
+  it "should not advance y-position of a stretchy bbox if it would stretch " +
+     "the bbox further" do
+    bottom = @pdf.y = @pdf.margin_box.absolute_bottom
+    @pdf.bounding_box [0, @pdf.margin_box.top], :width => @pdf.bounds.width do
+      @pdf.y = bottom
+      @pdf.text "hello" # starts a new page
+    end
+    @pdf.page_count.should == 2
+
+    # Restoring the position (to the absolute bottom) would stretch the bbox to
+    # the bottom of the page, which we don't want. This should be equivalent to
+    # a bbox with :hold_position => true, where we only advance by the amount
+    # that was actually drawn.
+    @pdf.y.should.be.close(
+      @pdf.margin_box.absolute_top - @pdf.height_of("hello"),
+      0.001
+    )
+  end
+
 end
 
 describe "Indentation" do
@@ -221,3 +266,115 @@ describe "A canvas" do
     @pdf.y.should == 450
   end
 end
+
+describe "Deep-copying" do
+  it "should create a new object that does not copy @document" do
+    Prawn::Document.new do
+      orig = bounds
+      copy = orig.deep_copy
+
+      copy.should.not == bounds
+      copy.document.should.be.nil
+    end
+  end
+
+  it "should deep-copy parent bounds" do
+    Prawn::Document.new do |pdf|
+      outside = pdf.bounds
+      pdf.bounding_box [100, 100], :width => 100 do
+        copy = pdf.bounds.deep_copy
+
+        # the parent bounds should have the same parameters
+        copy.parent.width.should  == outside.width
+        copy.parent.height.should == outside.height
+
+        # but should not be the same object
+        copy.parent.should.not == outside
+      end
+    end
+  end
+end
+
+describe "Prawn::Document#reference_bounds" do
+  before(:each) { create_pdf }
+
+  it "should return self for non-stretchy bounds" do
+    @pdf.bounding_box([0, @pdf.cursor], :width => 100, :height => 100) do
+      @pdf.reference_bounds.should == @pdf.bounds
+    end
+  end
+
+  it "should return the parent bounds if in a stretchy box" do
+    @pdf.bounding_box([0, @pdf.cursor], :width => 100, :height => 100) do
+      correct_bounds = @pdf.bounds
+      @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
+        @pdf.reference_bounds.should == correct_bounds
+      end
+    end
+  end
+
+  it "should find the non-stretchy box through 2 levels" do
+    @pdf.bounding_box([0, @pdf.cursor], :width => 100, :height => 100) do
+      correct_bounds = @pdf.bounds
+      @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
+        @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
+          @pdf.reference_bounds.should == correct_bounds
+        end
+      end
+    end
+  end
+
+  it "should return the margin box if there's no explicit bbox" do
+    @pdf.reference_bounds.should == @pdf.margin_box
+
+    @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
+      @pdf.reference_bounds.should == @pdf.margin_box
+    end
+  end
+
+  it "should return the canvas box if we're in a canvas" do
+    @pdf.canvas do
+      canvas_box = @pdf.bounds
+
+      @pdf.reference_bounds.should == canvas_box
+
+      @pdf.bounding_box([0, @pdf.cursor], :width => 100) do
+        @pdf.reference_bounds.should == canvas_box
+      end
+    end
+  end
+
+end
+
+describe "BoundingBox#move_past_bottom" do
+  before(:each) { create_pdf }
+
+  it "should ordinarily start a new page" do
+    @pdf.bounds.move_past_bottom
+    @pdf.text "Foo"
+
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+    pages.size.should == 2
+    pages[0][:strings].should == []
+    pages[1][:strings].should == ["Foo"]
+  end
+
+  it "should move to the top of the next page if it exists already" do
+    # save away the y-position at the top of a page
+    top_y = @pdf.y
+
+    # create a blank page but go to the page before it
+    @pdf.start_new_page
+    @pdf.go_to_page 1
+    @pdf.text "Foo"
+
+    @pdf.bounds.move_past_bottom
+    @pdf.y.should.be.close(top_y, 0.001) # we should be at the top
+    @pdf.text "Bar"
+
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+    pages.size.should == 2
+    pages[0][:strings].should == ["Foo"]
+    pages[1][:strings].should == ["Bar"]
+  end
+end