prawn-layout 0.1.0 → 0.2.0.1

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/testtask'
 require "rake/rdoctask"
 require "rake/gempackagetask"  
 
-PRAWN_LAYOUT_VERSION = "0.1.0" 
+PRAWN_LAYOUT_VERSION = "0.2.0.1"
 
 task :default => [:test]
        

data/examples/grid/simple_grid.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8    
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require "rubygems"
+require "prawn"   
+require "prawn/layout"
+
+Prawn::Document.generate('simple_grid.pdf') do |p|
+  p.define_grid(:columns => 5, :rows => 8, :gutter => 10)
+  
+  p.grid.rows.times do |i|
+    p.grid.columns.times do |j|
+      b = p.grid(i,j)
+      p.bounding_box b.top_left, :width => b.width, :height => b.height do
+        p.text b.name
+        p.stroke do
+          p.rectangle(p.bounds.top_left, b.width, b.height)
+        end
+      end
+    end
+  end
+end
+

data/examples/page_layout/flowing_text_with_header_and_footer.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8       
+# 
+# Multi-faceted example that demonstrates a document flowing between header
+# and footer regions.  At the moment, headers and footers in Prawn are run
+# using the current font settings (among other things), for each page.  This
+# means that it is important to non-destructively set your desired styling 
+# within your headers and footers, as shown below.  
+#
+# Future versions of Prawn may make this more convenient somehow.
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require "rubygems"
+require "prawn"   
+require "prawn/layout"
+
+Prawn::Document.generate("flow_with_headers_and_footers.pdf")  do
+
+  header margin_box.top_left do 
+    font "Helvetica" do
+      text "Here's My Fancy Header", :size => 25, :align => :center   
+      stroke_horizontal_rule
+    end
+  end   
+                
+  footer [margin_box.left, margin_box.bottom + 25] do
+    font "Helvetica" do
+      stroke_horizontal_rule
+      text "And here's a sexy footer", :size => 16
+    end
+  end
+                                      
+  bounding_box([bounds.left, bounds.top - 50], 
+      :width  => bounds.width, :height => bounds.height - 100) do                 
+   text "this is some flowing text " * 200    
+   
+   
+ end    
+ 
+end

data/examples/page_layout/lazy_bounding_boxes.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+#
+# This example demonstrates Document#lazy_bounding_box, which is used for
+# storing a set of drawing instructions to be executed later.  This is used
+# for header and footer support in Prawn, and can be used for repeating page
+# elements in general.
+#
+# Note that once a lazy bounding box is positioned, it calculates its anchor
+# relative to its parent bounding box.  It will be positioned at this exact
+# location each time it is redrawn, regardless of the bounds 
+# LazyBoundingBox#draw is in.
+# 
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require "rubygems"
+require "prawn"   
+require "prawn/layout"
+
+file = "lazy_bounding_boxes.pdf"
+Prawn::Document.generate(file, :skip_page_creation => true) do
+  point = [bounds.right-50, bounds.bottom + 25]
+  page_counter = lazy_bounding_box(point, :width => 50) do
+    text "Page: #{page_count}"
+  end 
+  
+  10.times do
+    start_new_page
+    text "Some filler text for the page"  
+    page_counter.draw
+  end
+end

data/examples/page_layout/padded_box.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+#
+# Padded box is a kind of bounding box which places padding on all sides of
+# the current bounds.  This is easier to see than explain, so please run the
+# example.
+#
+# Feature borrowed from Josh Knowle's pt at:
+# http://github.com/joshknowles/pt/tree/master
+#
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+require "rubygems"
+require "prawn"   
+require "prawn/layout"
+
+Prawn::Document.generate('padded_box.pdf') do
+  stroke_bounds
+  text "Margin box"
+  padded_box(25) do
+    stroke_bounds
+    text "Bounding box padded by 25 on all sides from the margins"
+    padded_box(50) do
+      stroke_bounds
+      text "Bounding box padded by 50 on all sides from the parent bounds"
+    end
+  end
+end

data/examples/table/cell.rb

@@ -19,8 +19,8 @@ Prawn::Document.generate("cell.pdf") do
     :border_width => 3, :padding => 10,
     :text => "And that puppies are made of gravy", :document => self, :font_size => 9)
   cell3 = Prawn::Table::Cell.new(
-    :border_width => 3, :padding => 10, :width => 100, 
-    :text => "This is simply the way of the world", :document => self)
+    :border_width => 3, :padding => 10, :width => 100,
+    :text => "This is simply the way of the world", :document => self, :font_style => :bold)
 
     3.times do
       cellblock = Prawn::Table::CellBlock.new(self)

data/lib/prawn/layout.rb

@@ -1,4 +1,6 @@
 require "prawn/table"
+require "prawn/layout/page"
+require 'prawn/layout/grid'
 
 module Prawn
   
@@ -14,6 +16,6 @@ module Prawn
  end
 
  module Layout
-   VERSION = "0.1.0"
+   VERSION = "0.2.0.1"
  end
 end

data/lib/prawn/layout/grid.rb

@@ -0,0 +1,238 @@
+module Prawn
+  class Document
+    # Defines the grid system for a particular document.  Takes the number of rows and columns and the
+    # width to use for the gutter as the keys :rows, :columns, :gutter
+    #
+    def define_grid(options = {})
+      @grid = Grid.new(self, options)
+    end
+  
+    # A method that can either be used to access a particular grid on the page or interogate the grid 
+    # system directly.
+    #
+    #   @pdf.grid                 # Get the Grid directly
+    #   @pdf.grid([0,1])          # Get the box at [0,1]
+    #   @pdf.grid([0,1], [1,2])   # Get a multi-box spanning from [0,1] to [1,2]
+    def grid(*args)
+      @boxes ||= {}
+      @boxes[args] ||= if args.empty?
+        @grid
+      else
+        g1, g2 = args
+        if(g1.class == Array && g2.class == Array && 
+          g1.length == 2 && g2.length == 2)
+          multi_box(single_box(*g1), single_box(*g2))
+        else
+          single_box(g1, g2)
+        end
+      end
+    end
+  
+    # A Grid represents the entire grid system of a Page and calculates the column width and row height
+    # of the base box.
+    class Grid
+      attr_reader :pdf, :columns, :rows, :gutter
+      # :nodoc
+      def initialize(pdf, options = {})
+        Prawn.verify_options([:columns, :rows, :gutter], options)
+      
+        @pdf = pdf
+        @columns = options[:columns]
+        @rows = options[:rows]
+        @gutter = options[:gutter].to_f
+      end
+
+      # Calculates the base width of boxes.
+      def column_width
+        @column_width ||= subdivide(pdf.bounds.width, columns)
+      end
+    
+      # Calculates the base height of boxes.
+      def row_height
+       @row_height ||= subdivide(pdf.bounds.height, rows)
+      end
+
+      # Diagnostic tool to show all of the grids.  Defaults to gray.
+      def show_all(color = "CCCCCC")
+        self.rows.times do |i|
+          self.columns.times do |j|
+            pdf.grid(i,j).show(color)
+          end
+        end
+      end
+
+      private
+      def subdivide(total, num)
+        (total.to_f - (gutter * (num - 1).to_f)) / num.to_f
+      end
+    end
+  
+    # A Box is a class that represents a bounded area of a page.  A Grid object has methods that allow 
+    # easy access to the coordinates of its corners, which can be plugged into most existing prawn 
+    # methods.
+    #
+    class Box
+      attr_reader :pdf
+    
+      def initialize(pdf, i, j)
+        @pdf = pdf
+        @i = i
+        @j = j
+      end
+    
+      # Mostly diagnostic method that outputs the name of a box as col_num, row_num
+      def name
+        "#{@i.to_s},#{@j.to_s}"
+      end
+      
+      # :nodoc
+      def total_height
+        pdf.bounds.height.to_f
+      end
+      
+      # Width of a box
+      def width
+        grid.column_width.to_f
+      end
+    
+      # Height of a box
+      def height
+        grid.row_height.to_f
+      end
+      
+      # Width of the gutter
+      def gutter
+        grid.gutter.to_f
+      end
+      
+      # x-coordinate of left side
+      def left
+        @left ||= (width + gutter) * @j.to_f
+      end
+    
+      # x-coordinate of right side 
+      def right
+        @right ||= left + width
+      end
+    
+      # y-coordinate of the top
+      def top
+        @top ||= total_height - ((height + gutter) * @i.to_f)
+      end
+    
+      # y-coordinate of the bottom
+      def bottom
+        @bottom ||= top - height
+      end
+    
+      # x,y coordinates of top left corner
+      def top_left
+        [left, top]
+      end
+    
+      # x,y coordinates of top right corner    
+      def top_right
+        [right, top]
+      end
+    
+      # x,y coordinates of bottom left corner
+      def bottom_left
+        [left, bottom]
+      end
+    
+      # x,y coordinates of bottom right corner
+      def bottom_right
+        [right, bottom]
+      end
+    
+      # Creates a standard bounding box based on the grid box.
+      def bounding_box(&blk)
+        pdf.bounding_box(top_left, :width => width, :height => height, &blk)
+      end
+    
+      # Diagnostic method
+      def show(grid_color = "CCCCCC")
+        self.bounding_box do
+          pdf.stroke_color = grid_color
+          pdf.text self.name
+          pdf.stroke_bounds
+        end
+      end
+    
+      private
+      def grid
+        pdf.grid
+      end
+    end
+  
+    # A MultiBox is specified by 2 Boxes and spans the areas between.
+    class MultiBox < Box
+      def initialize(pdf, b1, b2)
+        @pdf = pdf
+        @bs = [b1, b2]
+      end
+    
+      def name
+        @bs.map {|b| b.name}.join(":")
+      end
+    
+      def total_height
+        @bs[0].total_height
+      end
+
+      def width
+        right_box.right - left_box.left
+      end
+    
+      def height
+        top_box.top - bottom_box.bottom
+      end
+    
+      def gutter
+        @bs[0].gutter
+      end
+    
+      def left
+        left_box.left
+      end
+    
+      def right
+        right_box.right
+      end
+    
+      def top
+        top_box.top
+      end
+    
+      def bottom
+        bottom_box.bottom
+      end
+    
+      private
+      def left_box
+        @left_box ||= @bs.min {|a,b| a.left <=> b.left}
+      end
+    
+      def right_box
+        @right_box ||= @bs.max {|a,b| a.right <=> b.right}
+      end
+    
+      def top_box
+        @top_box ||= @bs.max {|a,b| a.top <=> b.top}
+      end
+    
+      def bottom_box
+        @bottom_box ||= @bs.min {|a,b| a.bottom <=> b.bottom}
+      end
+    end
+  
+    private
+    def single_box(i, j)
+      Box.new(self, i, j)
+    end
+  
+    def multi_box(b1, b2)
+      MultiBox.new(self, b1, b2)
+    end
+  end
+end

data/lib/prawn/layout/page.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+# layout/page.rb : Provides helpers for page layout
+#
+# Copyright January 2009, Gregory Brown. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Document
+    # A LazyBoundingBox is simply a BoundingBox with an action tied to it to be 
+    # executed later.  The lazy_bounding_box method takes the same arguments as
+    # bounding_box, but returns a LazyBoundingBox object instead of executing
+    # the code block directly.
+    #
+    # You can then call LazyBoundingBox#draw at any time (or multiple times if 
+    # you wish), and the contents of the block will then be run. This can be
+    # useful for assembling repeating page elements or reusable components.
+    #
+    #  file = "lazy_bounding_boxes.pdf"
+    #  Prawn::Document.generate(file, :skip_page_creation => true) do                    
+    #    point = [bounds.right-50, bounds.bottom + 25]
+    #    page_counter = lazy_bounding_box(point, :width => 50) do   
+    #      text "Page: #{page_count}"
+    #    end 
+    #
+    #    10.times do         
+    #     start_new_page
+    #      text "Some text"  
+    #      page_counter.draw
+    #    end
+    #  end
+    #
+    def lazy_bounding_box(*args,&block)
+      translate!(args[0])  
+      box = LazyBoundingBox.new(self,*args)
+      box.action(&block)
+      return box 
+    end
+    
+    # A bounding box with the same dimensions of its parents, minus a margin
+    # on all sides
+    #
+    def padded_box(margin, &block)
+      bounding_box [bounds.left + margin, bounds.top - margin],
+        :width  => bounds.width - (margin * 2), 
+        :height => bounds.height - (margin * 2), &block 
+    end
+       
+    # A header is a LazyBoundingBox drawn relative to the margins that can be
+    # repeated on every page of the document.
+    #
+    # Unless <tt>:width</tt> or <tt>:height</tt> are specified, the margin_box
+    # width and height are used.   
+    #
+    #   header margin_box.top_left do 
+    #    text "Here's My Fancy Header", :size => 25, :align => :center   
+    #    stroke_horizontal_rule
+    #  end
+    #
+    def header(top_left,options={},&block)   
+      @header = repeating_page_element(top_left,options,&block)
+    end
+        
+    # A footer is a LazyBoundingBox drawn relative to the margins that can be
+    # repeated on every page of the document.
+    #
+    # Unless <tt>:width</tt> or <tt>:height</tt> are specified, the margin_box
+    # width and height are used.
+    #
+    #   footer [margin_box.left, margin_box.bottom + 25] do
+    #     stroke_horizontal_rule
+    #     text "And here's a sexy footer", :size => 16
+    #   end    
+    #
+    def footer(top_left,options={},&block)       
+      @footer = repeating_page_element(top_left,options,&block)
+    end
+
+    private
+
+    def repeating_page_element(top_left,options={},&block)   
+      r = LazyBoundingBox.new(self, translate(top_left),
+        :width  => options[:width]  || margin_box.width, 
+        :height => options[:height] || margin_box.height )
+      r.action(&block)
+      return r
+    end  
+
+    class LazyBoundingBox < BoundingBox
+       
+      # Defines the block to be executed by LazyBoundingBox#draw. 
+      # Usually, this will be used via a higher level interface.  
+      # See the documentation for Document#lazy_bounding_box, Document#header,
+      # and Document#footer
+      #
+      def action(&block)
+        @action = block
+      end
+      
+      # Sets Document#bounds to use the LazyBoundingBox for its bounds,
+      # runs the block specified by LazyBoundingBox#action,
+      # and then restores the original bounds of the document.
+      #
+      def draw
+        @parent.mask(:y) do  
+          parent_box = @parent.bounds  
+          @parent.bounds = self    
+          @parent.y = absolute_top
+          @action.call   
+          @parent.bounds = parent_box
+        end
+      end
+    end
+  end
+end

data/lib/prawn/table.rb

@@ -42,7 +42,7 @@ module Prawn
     #   Will raise <tt>Prawn::Errors::EmptyTable</tt> given 
     #   a nil or empty <tt>data</tt> paramater.
     #
-    def table(data,options={})           
+    def table(data, options={})           
       if data.nil? || data.empty?
         raise Prawn::Errors::EmptyTable,
           "data must be a non-empty, non-nil, two dimensional array of Prawn::Cells or strings"
@@ -107,7 +107,6 @@ module Prawn
     # <tt>:column_widths:</tt> A hash of indices and widths in PDF points.  E.g. <tt>{ 0 => 50, 1 => 100 }</tt>
     # <tt>:row_colors</tt>:: An array of row background colors which are used cyclicly.   
     # <tt>:align</tt>:: Alignment of text in columns, for entire table (<tt>:center</tt>) or by column (<tt>{ 0 => :left, 1 => :center}</tt>)
-    # <tt>:minimum_rows</tt>:: The minimum rows to display on a page, including header.
     #
     # Row colors are specified as html encoded values, e.g.
     # ["ffffff","aaaaaa","ccaaff"].  You can also specify 
@@ -117,7 +116,7 @@ module Prawn
     # See Document#table for typical usage, as directly using this class is
     # not recommended unless you know why you want to do it.
     #
-    def initialize(data, document,options={})     
+    def initialize(data, document, options={})     
       unless data.all? { |e| Array === e }
         raise Prawn::Errors::InvalidTableData,
           "data must be a two dimensional array of Prawn::Cells or strings"
@@ -190,15 +189,28 @@ module Prawn
     def calculate_column_widths(manual_widths=nil, width=nil)
       @column_widths = [0] * @data[0].inject(0){ |acc, e| 
         acc += (e.is_a?(Hash) && e.has_key?(:colspan)) ? e[:colspan] : 1 }
+
       renderable_data.each do |row|
+        colspan = 0
         row.each_with_index do |cell,i|
-          length = cell.to_s.lines.map { |e| 
-            @document.font.width_of(e, :size => C(:font_size)) }.max.to_f +
+          cell_text = cell.is_a?(Hash) ? cell[:text] : cell.to_s
+          length = cell_text.lines.map { |e|
+            @document.width_of(e, :size => C(:font_size)) }.max.to_f +
               2*C(:horizontal_padding)
-          @column_widths[i] = length.ceil if length > @column_widths[i]
+          if length > @column_widths[i+colspan]
+            @column_widths[i+colspan] = length.ceil
+          end
+
+          if cell.is_a?(Hash) && cell[:colspan]
+            colspan += cell[:colspan] - 1
+          end
         end
       end  
 
+      fit_within_bounds(manual_widths, width)
+    end
+
+    def fit_within_bounds(manual_widths, width)
       manual_width = 0
       manual_widths.each { |k,v| 
         @column_widths[k] = v; manual_width += v } if manual_widths           
@@ -227,6 +239,7 @@ module Prawn
       end
     end
 
+
     def renderable_data
       C(:headers) ? [C(:headers)] + @data : @data
     end
@@ -270,15 +283,18 @@ module Prawn
                 @column_widths[col_index]
               end
               
-              c << Prawn::Table::Cell.new(
-                :document => @document, 
+              cell_options = {:document => @document, 
                 :text     => text,
                 :width    => width,
                 :horizontal_padding => C(:horizontal_padding),
                 :vertical_padding   => C(:vertical_padding),
                 :border_width       => C(:border_width),
                 :border_style       => :sides,
-                :align              => align ) 
+                :align              => align}
+              cell_options[:font_style] = e[:font_style] if e.is_a?(Hash) && e.has_key?(:font_style)
+              cell_options[:font_size] = e[:font_size] if e.is_a?(Hash) && e.has_key?(:font_size)
+
+              c << Prawn::Table::Cell.new(cell_options)
             end
             
             col_index += (e.is_a?(Hash) && e.has_key?(:colspan)) ? e[:colspan] : 1

data/lib/prawn/table/cell.rb

@@ -52,6 +52,7 @@ module Prawn
       # <tt>:border_style</tt>:: One of <tt>:all</tt>, <tt>:no_top</tt>, <tt>:no_bottom</tt>, <tt>:sides</tt>, <tt>:none</tt>, <tt>:bottom_only</tt>. Defaults to :all.
       # <tt>:border_color</tt>:: The color of the cell border.
       # <tt>:font_size</tt>:: The font size for the cell text.
+      # <tt>:font_style</tt>:: The font style for the cell text.
       #
       def initialize(options={})
         @point        = options[:point]
@@ -67,6 +68,7 @@ module Prawn
         @background_color = options[:background_color] 
         @align            = options[:align] || :left
         @font_size        = options[:font_size]
+        @font_style       = options[:font_style]
 
         @horizontal_padding = options[:horizontal_padding] || 0
         @vertical_padding   = options[:vertical_padding]   || 0
@@ -78,7 +80,7 @@ module Prawn
 
       attr_accessor :point, :border_style, :border_width, :background_color,
                     :document, :horizontal_padding, :vertical_padding, :align,
-                    :borders, :text_color, :border_color
+                    :borders, :text_color, :border_color, :font_size, :font_style
                     
       attr_writer   :height, :width #:nodoc:   
            
@@ -97,7 +99,7 @@ module Prawn
       # The width of the cell in PDF points
       #
       def width
-        @width || (@document.font.width_of(@text, :size => @font_size)) + 2*@horizontal_padding
+        @width || (@document.width_of(@text, :size => @font_size)) + 2*@horizontal_padding
       end
 
       # The height of the cell in PDF points
@@ -109,7 +111,15 @@ module Prawn
       # The height of the text area excluding the vertical padding
       #
       def text_area_height
-        @document.height_of(@text, text_area_width)
+        text_height = 0
+        if @font_size
+          @document.font_size(@font_size) do
+            text_height = @document.height_of(@text, text_area_width)
+          end
+        else
+          text_height = @document.height_of(@text, text_area_width)
+        end
+        text_height
       end
 
       # Draws the cell onto the PDF document
@@ -173,6 +183,7 @@ module Prawn
           options = {:align => @align, :final_gap => false}
 
           options[:size] = @font_size if @font_size
+          options[:style] = @font_style if @font_style
 
           @document.mask(:fill_color) do
             @document.fill_color @text_color if @text_color                        

data/spec/grid_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
+
+describe "A document's grid" do
+  before do
+    @pdf = Prawn::Document.new
+  end
+  
+  it "should allow definition of a grid" do
+    @pdf.define_grid(:columns => 5, :rows => 8, :gutter => 0.1)
+    @pdf.grid.columns.should == 5
+    @pdf.grid.rows.should == 8
+    @pdf.grid.gutter.should == 0.1
+  end
+  
+  describe "when a grid is defined" do
+    before do
+      @num_columns = 5
+      @num_rows = 8
+      @gutter = 10.0
+      @pdf.define_grid(
+        :columns => @num_columns, 
+        :rows => @num_rows, 
+        :gutter => @gutter
+      )
+    end
+    
+    it "should compute the column width" do
+      (@pdf.grid.column_width * @num_columns.to_f + 
+        @gutter * (@num_columns - 1).to_f).should == @pdf.bounds.width
+    end
+    
+    it "should compute the row height" do
+      (@pdf.grid.row_height * @num_rows.to_f + 
+        @gutter * (@num_rows - 1).to_f).should == @pdf.bounds.height
+    end
+
+    it "should give the edges of a grid box" do
+      grid_width = (@pdf.bounds.width.to_f - 
+        (@gutter * (@num_columns - 1).to_f )) / @num_columns.to_f
+      grid_height = (@pdf.bounds.height.to_f - 
+        (@gutter * (@num_rows - 1).to_f ))/ @num_rows.to_f
+      
+      exp_tl_x = (grid_width + @gutter.to_f) * 4.0
+      exp_tl_y = @pdf.bounds.height.to_f - (grid_height + @gutter.to_f)
+
+      @pdf.grid(1,4).top_left.should      == [exp_tl_x, exp_tl_y]
+      @pdf.grid(1,4).top_right.should     == [exp_tl_x + grid_width, exp_tl_y]
+      @pdf.grid(1,4).bottom_left.should   == [exp_tl_x, exp_tl_y - grid_height]
+      @pdf.grid(1,4).bottom_right.should  == [exp_tl_x + grid_width, exp_tl_y - grid_height]
+    end
+
+    it "should give the edges of a multiple grid boxes" do
+      # Hand verified.  Cheating a bit.  Don't tell.
+      @pdf.grid([1,3], [2,5]).top_left.should     == [330.0, 628.75]
+      @pdf.grid([1,3], [2,5]).top_right.should    == [650.0, 628.75]
+      @pdf.grid([1,3], [2,5]).bottom_left.should  == [330.0, 456.25]
+      @pdf.grid([1,3], [2,5]).bottom_right.should == [650.0, 456.25]
+    end
+  end
+end

data/spec/page_layout_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper") 
+
+describe "When beginning each new page" do
+
+  it "should execute codeblock given to Document#header" do
+    call_count = 0    
+   
+    pdf = Prawn::Document.new      
+    pdf.header(pdf.margin_box.top_left) do 
+      call_count += 1   
+    end
+    
+    pdf.start_new_page 
+    pdf.start_new_page 
+    pdf.render
+    
+    call_count.should == 3
+  end
+
+end
+
+describe "When ending each page" do
+
+  it "should execute codeblock given to Document#footer" do
+   
+    call_count = 0    
+   
+    pdf = Prawn::Document.new      
+    pdf.footer([pdf.margin_box.left, pdf.margin_box.bottom + 50]) do 
+      call_count += 1   
+    end
+    
+    pdf.start_new_page 
+    pdf.start_new_page 
+    pdf.render
+    
+    call_count.should == 3
+  end
+
+end

data/spec/spec_helper.rb

@@ -5,7 +5,7 @@ puts "Prawn specs: Running on Ruby Version: #{RUBY_VERSION}"
 require "rubygems"
 require "test/spec"                                                
 require "mocha"
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib') 
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib') 
 
 require "prawn"
 require "prawn/layout"

data/spec/table_spec.rb

@@ -10,6 +10,25 @@ describe "A table's width" do
 
     table.width.should == 300
   end
+  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" ],
+             [ "foo", "foo", "foo" ] ]
+    table = Prawn::Table.new( data, pdf,
+      :horizontal_padding => hpad,
+      :font_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
+  end
 
   it "should calculate unspecified column widths as "+
      "(max(string_width).ceil + 2*horizontal_padding)" do
@@ -19,8 +38,8 @@ describe "A table's width" do
     table = Prawn::Table.new( [%w[ foo b ], %w[d foobar]], pdf,
       :horizontal_padding => hpad, :font_size => fs)
 
-    col0_width = pdf.font.width_of("foo", :size => fs)
-    col1_width = pdf.font.width_of("foobar", :size => fs)
+    col0_width = pdf.width_of("foo", :size => fs)
+    col1_width = pdf.width_of("foobar", :size => fs)
 
     table.width.should == col0_width.ceil + col1_width.ceil + 2*columns*hpad
   end
@@ -33,8 +52,8 @@ describe "A table's width" do
     stretchy_columns = 2
     
     col0_width = 50
-    col1_width = pdf.font.width_of("foo", :size => fs)
-    col2_width = pdf.font.width_of("foobar", :size => fs)
+    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], 
@@ -54,7 +73,9 @@ describe "A table's width" 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', 'and then some more', 'Just a bit more to be extra sure']
+      ['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', 
+      'and then some more', 'Just a bit more to be extra sure']
     ]
 
     table = Prawn::Table.new(data, pdf)
@@ -69,9 +90,12 @@ describe "A table's width" 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', 'and then some more', 'Just a bit more to be extra sure']
+      ['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', 
+      'and then some more', 'Just a bit more to be extra sure']
     ]
 
+
     table = Prawn::Table.new(data, pdf, :column_widths => { 1 => 100 })
 
     table.width.should == expected_width
@@ -98,7 +122,9 @@ describe "A table's width" 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', 'and then some more', 'Just a bit more to be extra sure']
+      ['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', 
+      'and then some more', 'Just a bit more to be extra sure']
     ]
 
     table = Prawn::Table.new(data, pdf, :width => expected_width)
@@ -113,7 +139,9 @@ describe "A table's width" 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', 'and then some more', 'Just a bit more to be extra sure']
+      ['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', 
+      'and then some more', 'Just a bit more to be extra sure']
     ]
 
     table = Prawn::Table.new(data, pdf, :column_widths => { 1 => 100 }, :width => expected_width)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: prawn-layout
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0.1
 platform: ruby
 authors: 
 - Gregory Brown
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-17 00:00:00 -05:00
+date: 2009-06-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
-description: An extension to Prawn that provides table support and other layout functionality
+description: "  An extension to Prawn that provides table support and other layout functionality\n"
 email: "  gregory.t.brown@gmail.com"
 executables: []
 
@@ -22,7 +22,10 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- examples/table
+- examples/grid/simple_grid.rb
+- examples/page_layout/flowing_text_with_header_and_footer.rb
+- examples/page_layout/lazy_bounding_boxes.rb
+- examples/page_layout/padded_box.rb
 - examples/table/addressbook.csv
 - examples/table/cell.rb
 - examples/table/currency.csv
@@ -34,16 +37,20 @@ files:
 - examples/table/table_header_color.rb
 - examples/table/table_header_underline.rb
 - examples/table/table_widths.rb
-- lib/prawn
+- lib/prawn/layout/grid.rb
+- lib/prawn/layout/page.rb
 - lib/prawn/layout.rb
-- lib/prawn/table
 - lib/prawn/table/cell.rb
 - lib/prawn/table.rb
+- spec/grid_spec.rb
+- spec/page_layout_spec.rb
 - spec/spec_helper.rb
 - spec/table_spec.rb
 - Rakefile
 has_rdoc: true
 homepage: http://prawn.majesticseacreature.com
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --title
@@ -65,9 +72,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: prawn
-rubygems_version: 1.3.1
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: An extension to Prawn that provides table support and other layout functionality
 test_files: []