prawn 1.0.0.rc1 → 1.0.0.rc2

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

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+# span_dummy.rb: Placeholder for non-master spanned cells.
+#
+# Copyright December 2011, Brad Ediger. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+module Prawn
+  class Table
+    class Cell
+
+      # A Cell object used to represent all but the topmost cell in a span
+      # group.
+      #
+      class SpanDummy < Cell
+        def initialize(pdf, master_cell)
+          super(pdf, [0, pdf.cursor])
+          @master_cell = master_cell
+          @padding = [0, 0, 0, 0]
+        end
+
+        # By default, a span dummy will never increase the height demand.
+        #
+        def natural_content_height
+          0
+        end
+
+        # By default, a span dummy will never increase the width demand.
+        #
+        def natural_content_width
+          0
+        end
+
+        def avg_spanned_min_width
+          @master_cell.avg_spanned_min_width
+        end
+
+        # Dummy cells have nothing to draw.
+        #
+        def draw_borders(pt)
+        end
+
+        # Dummy cells have nothing to draw.
+        #
+        def draw_bounded_content(pt)
+        end
+
+        def padding_right=(val)
+          @master_cell.padding_right = val if rightmost?
+        end
+
+        def padding_bottom=(val)
+          @master_cell.padding_bottom = val if bottommost?
+        end
+
+        def border_right_color=(val)
+          @master_cell.border_right_color = val if rightmost?
+        end
+
+        def border_bottom_color=(val)
+          @master_cell.border_bottom_color = val if bottommost?
+        end
+
+        def border_right_width=(val)
+          @master_cell.border_right_width = val if rightmost?
+        end
+
+        def border_bottom_width=(val)
+          @master_cell.border_bottom_width = val if bottommost?
+        end
+
+        private
+
+        # Are we on the right border of the span?
+        #
+        def rightmost?
+          @column == @master_cell.column + @master_cell.colspan - 1
+        end
+
+        # Are we on the bottom border of the span?
+        #
+        def bottommost?
+          @row == @master_cell.row + @master_cell.rowspan - 1
+        end
+      end
+    end
+  end
+end

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

@@ -47,7 +47,7 @@ module Prawn
         # from the final width if the text is long.
         #
         def natural_content_width
-          [styled_width_of(@content), @pdf.bounds.width].min
+          @natural_content_width ||= [styled_width_of(@content), @pdf.bounds.width].min
         end
 
         # Returns the natural height of this block of text, wrapped to the
@@ -55,7 +55,7 @@ module Prawn
         #
         def natural_content_height
           with_font do
-            b = text_box(:width => content_width + FPTolerance)
+            b = text_box(:width => spanned_content_width + FPTolerance)
             b.render(:dry_run => true)
             b.height + b.line_gap
           end
@@ -67,8 +67,8 @@ module Prawn
           with_font do 
             @pdf.move_down((@pdf.font.line_gap + @pdf.font.descender)/2)
             with_text_color do
-              text_box(:width => content_width + FPTolerance, 
-                       :height => content_height + FPTolerance,
+              text_box(:width => spanned_content_width + FPTolerance,
+                       :height => spanned_content_height + FPTolerance,
                        :at => [0, @pdf.cursor]).render
             end
           end
@@ -78,9 +78,11 @@ module Prawn
           # 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
           # a bit of a hack, but it should work well enough.
-          min_content_width = [natural_content_width, styled_width_of("M")].min
-          @min_width ||= padding_left + padding_right + min_content_width
-          super
+          unless @min_width
+            min_content_width = [natural_content_width, styled_width_of_single_character].min
+            @min_width = padding_left + padding_right + min_content_width
+            super
+          end
         end
 
         protected
@@ -97,21 +99,28 @@ module Prawn
         end
 
         def with_text_color
-          old_color = @pdf.fill_color || '000000'
-          @pdf.fill_color(@text_color) if @text_color
-          yield
-        ensure
-          @pdf.fill_color(old_color)
+          if @text_color
+            begin
+              old_color = @pdf.fill_color || '000000'
+              @pdf.fill_color(@text_color)
+              yield
+            ensure
+              @pdf.fill_color(old_color)
+            end
+          else
+            yield
+          end
         end
         
         def text_box(extra_options={})
           if @text_options[:inline_format]
             options = @text_options.dup
             options.delete(:inline_format)
+            options.merge!(extra_options)
+            options[:document] = @pdf
 
             array = ::Prawn::Text::Formatted::Parser.to_array(@content)
-            ::Prawn::Text::Formatted::Box.new(array,
-              options.merge(extra_options).merge(:document => @pdf))
+            ::Prawn::Text::Formatted::Box.new(array, options)
           else
             ::Prawn::Text::Box.new(@content, @text_options.merge(extra_options).
                merge(:document => @pdf))
@@ -124,6 +133,19 @@ module Prawn
           @pdf.width_of(text, @text_options)
         end
 
+        private
+
+        # Returns the greatest possible width of any single character
+        #   under the given text options.
+        # (We use this to determine the minimum width of a table cell)
+        # (Although we currently determine this by measuring "M", it should really
+        #   use whichever character is widest under the current font)
+        #
+        def styled_width_of_single_character
+          key   = (@text_options[:style] == :bold) ? :bold_char_width : :plain_char_width
+          cache = Thread.current[key] ||= {}
+          cache[@pdf.font] ||= styled_width_of("M")
+        end
       end
     end
   end

data/lib/prawn/table/cells.rb

@@ -9,13 +9,6 @@
 module Prawn
   class Table
 
-    # Returns a Cells object that can be used to select and style cells. See
-    # the Cells documentation for things you can do with cells.
-    #
-    def cells
-      @cell_proxy ||= Cells.new(@cells)
-    end
-
     # Selects the given rows (0-based) for styling. Returns a Cells object --
     # see the documentation on Cells for things you can do with cells.
     #
@@ -54,13 +47,20 @@ module Prawn
       #
       def rows(row_spec)
         index_cells unless @indexed
-        row_spec = transform_spec(row_spec, @row_count)
+        row_spec = transform_spec(row_spec, @first_row, @row_count)
         Cells.new(@rows[row_spec] ||= select { |c|
                     row_spec.respond_to?(:include?) ?
                       row_spec.include?(c.row) : row_spec === c.row })
       end
       alias_method :row, :rows
-      
+
+      # Returns the number of rows in the list.
+      #
+      def row_count
+        index_cells unless @indexed
+        @row_count
+      end
+
       # Limits selection to the given column or columns. +col_spec+ can be
       # anything that responds to the === operator selecting a set of 0-based
       # column numbers; most commonly a number or a range.
@@ -70,13 +70,20 @@ module Prawn
       #
       def columns(col_spec)
         index_cells unless @indexed
-        col_spec = transform_spec(col_spec, @column_count)
+        col_spec = transform_spec(col_spec, @first_column, @column_count)
         Cells.new(@columns[col_spec] ||= select { |c|
                     col_spec.respond_to?(:include?) ? 
                       col_spec.include?(c.column) : col_spec === c.column })
       end
       alias_method :column, :columns
 
+      # Returns the number of columns in the list.
+      #
+      def column_count
+        index_cells unless @indexed
+        @column_count
+      end
+
       # Allows you to filter the given cells by arbitrary properties.
       #
       #   table.column(4).filter { |cell| cell.content =~ /Yes/ }.
@@ -92,7 +99,33 @@ module Prawn
       #   table.cells[0, 0].content # => "First cell content"
       #
       def [](row, col)
-        find { |c| c.row == row && c.column == col }
+        return nil if empty?
+        index_cells unless @indexed
+        row_array, col_array = @rows[@first_row + row] || [], @columns[@first_column + col] || []
+        if row_array.length < col_array.length
+          row_array.find { |c| c.column == @first_column + col }
+        else
+          col_array.find { |c| c.row == @first_row + row }
+        end
+      end
+
+      # Puts a cell in the collection at the given position. Internal use only.
+      #
+      def []=(row, col, cell) # :nodoc:
+        cell.extend(Cell::InTable)
+        cell.row = row
+        cell.column = col
+
+        if @indexed
+          (@rows[row]    ||= []) << cell
+          (@columns[col] ||= []) << cell
+          @first_row    = row if !@first_row    || row < @first_row
+          @first_column = col if !@first_column || col < @first_column
+          @row_count    = @rows.size
+          @column_count = @columns.size
+        end
+
+        self << cell
       end
 
       # Supports setting multiple properties at once.
@@ -110,51 +143,43 @@ module Prawn
       #   table.cells.style { |cell| cell.border_width += 12 }
       #
       def style(options={}, &block)
-        each { |cell| cell.style(options, &block) }
+        each do |cell|
+          next if cell.is_a?(Cell::SpanDummy)
+          cell.style(options, &block)
+        end
       end
 
       # Returns the total width of all columns in the selected set.
       #
       def width
-        column_widths = {}
-        each do |cell| 
-          column_widths[cell.column] = 
-            [column_widths[cell.column], cell.width].compact.max
+        widths = {}
+        each do |cell|
+          index = cell.column
+          per_cell_width = cell.width_ignoring_span.to_f / cell.colspan
+          cell.colspan.times do |n|
+            widths[cell.column+n] = [widths[cell.column+n], per_cell_width].
+              compact.max
+          end
         end
-        column_widths.values.inject(0) { |sum, width| sum + width }
+        widths.values.inject(0, &:+)
       end
 
       # Returns minimum width required to contain cells in the set.
       #
       def min_width
-        column_min_widths = {}
-        each do |cell| 
-          column_min_widths[cell.column] = 
-            [column_min_widths[cell.column], cell.min_width].compact.max
-        end
-        column_min_widths.values.inject(0) { |sum, width| sum + width }
+        aggregate_cell_values(:column, :avg_spanned_min_width, :max)
       end
 
       # Returns maximum width that can contain cells in the set.
       #
       def max_width
-        column_max_widths = {}
-        each do |cell| 
-          column_max_widths[cell.column] = 
-            [column_max_widths[cell.column], cell.max_width].compact.min
-        end
-        column_max_widths.values.inject(0) { |sum, width| sum + width }
+        aggregate_cell_values(:column, :max_width_ignoring_span, :min)
       end
 
       # Returns the total height of all rows in the selected set.
       #
       def height
-        row_heights = {}
-        each do |cell| 
-          row_heights[cell.row] = 
-            [row_heights[cell.row], cell.height].compact.max
-        end
-        row_heights.values.inject(0) { |sum, width| sum + width }
+        aggregate_cell_values(:row, :height_ignoring_span, :max)
       end
 
       # Supports setting arbitrary properties on a group of cells.
@@ -162,7 +187,11 @@ module Prawn
       #   table.cells.row(3..6).background_color = 'cc0000'
       #
       def method_missing(id, *args, &block)
-        each { |c| c.send(id, *args, &block) }
+        if id.to_s =~ /=\z/
+          each { |c| c.send(id, *args, &block) if c.respond_to?(id) }
+        else
+          super
+        end
       end
 
       protected
@@ -185,24 +214,45 @@ module Prawn
           @columns[cell.column] << cell
         end
 
+        @first_row    = @rows.keys.min
+        @first_column = @columns.keys.min
+
         @row_count    = @rows.size
         @column_count = @columns.size
 
         @indexed = true
       end
 
+      # Sum up a min/max value over rows or columns in the cells selected.
+      # Takes the min/max (per +aggregate+) of the result of sending +meth+ to
+      # each cell, grouped by +row_or_column+.
+      #
+      def aggregate_cell_values(row_or_column, meth, aggregate)
+        values = {}
+        each do |cell|
+          index = cell.send(row_or_column)
+          values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
+        end
+        values.values.inject(0, &:+)
+      end
+
       # Transforms +spec+, a column / row specification, into an object that
       # can be compared against a row or column number using ===. Normalizes
-      # negative indices to be positive, given a total size of +total+.
+      # negative indices to be positive, given a total size of +total+. The
+      # first row/column is indicated by +first+; this value is considered row
+      # or column 0.
       #
-      def transform_spec(spec, total)
+      def transform_spec(spec, first, total)
         case spec
         when Range
-          transform_spec(spec.begin, total)..transform_spec(spec.end, total)
+          transform_spec(spec.begin, first, total) ..
+            transform_spec(spec.end, first, total)
         when Integer
-          spec < 0 ? (total + spec) : spec
+          spec < 0 ? (first + total + spec) : first + spec
+        when Enumerable
+          spec.map { |x| first + x }
         else # pass through
-          spec
+          raise "Don't understand spec #{spec.inspect}"
         end
       end
     end

data/lib/prawn/text.rb

@@ -152,6 +152,7 @@ module Prawn
     # any text
     #
     def text(string, options={})
+      return false if string.nil?
       # we modify the options. don't change the user's hash
       options = options.dup
 
@@ -176,7 +177,7 @@ module Prawn
     #   text([{ :text => "hello" },
     #         { :text => "world",
     #           :size => 24,
-    #           :style => [:bold, :italic] }])
+    #           :styles => [:bold, :italic] }])
     #
     # == Options
     #
@@ -314,7 +315,7 @@ module Prawn
     #   height_of_formatted([{ :text => "hello" },
     #                        { :text => "world",
     #                          :size => 24,
-    #                          :style => [:bold, :italic] }])
+    #                          :styles => [:bold, :italic] }])
     #
     def height_of_formatted(array, options={})
       if options[:indent_paragraphs]

data/lib/prawn/text/formatted/box.rb

@@ -49,6 +49,9 @@ module Prawn
       #     created to that destination. Note that you must explicitly underline
       #     and color using the appropriate tags if you which to draw attention
       #     to the link
+      # <tt>:draw_text_callback</tt>:
+      #     if provided, this Proc will be called instead of #draw_text! once
+      #     per fragment for every low-level addition of text to the page.
       # <tt>:callback</tt>::
       #     an object (or array of such objects) with two methods:
       #     #render_behind and #render_in_front, which are called immediately
@@ -101,7 +104,8 @@ module Prawn
                                               :skip_encoding,
                                               :document,
                                               :direction,
-                                              :fallback_fonts]
+                                              :fallback_fonts,
+                                              :draw_text_callback]
         end
 
         # The text that was successfully printed (or, if <tt>dry_run</tt> was
@@ -205,6 +209,7 @@ module Prawn
           @rotate_around     = options[:rotate_around] || :upper_left
           @single_line       = options[:single_line]
           @skip_encoding     = options[:skip_encoding] || @document.skip_encoding
+          @draw_text_callback = options[:draw_text_callback]
 
           if @overflow == :expand
             # if set to expand, then we simply set the bottom
@@ -310,8 +315,13 @@ module Prawn
             draw_fragment_underlays(fragment)
 
             @document.word_spacing(word_spacing) {
-              @document.draw_text!(fragment.text, :at => [x, y],
-                                   :kerning => @kerning)
+              if @draw_text_callback
+                @draw_text_callback.call(fragment.text, :at => [x, y],
+                                         :kerning => @kerning)
+              else
+                @document.draw_text!(fragment.text, :at => [x, y],
+                                     :kerning => @kerning)
+              end
             }
 
             draw_fragment_overlays(fragment)
@@ -371,8 +381,7 @@ module Prawn
           # all fonts
           fallback_fonts << fragment_font
 
-          hash[:text].unpack("U*").each do |char_int|
-            char = [char_int].pack("U")
+          hash[:text].unicode_characters do |char|
             @document.font(fragment_font)
             font_glyph_pairs << [find_font_for_this_glyph(char,
                                                           @document.font.family,