prawn 0.15.0 → 1.0.0.rc1

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

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# encoding: utf-8   
 
 # image.rb: Table image cells.
 #
@@ -9,7 +9,8 @@ module Prawn
   class Table
     class Cell
 
-      # @private
+      # A Cell that contains another table.
+      #
       class Image < Cell
 
         def initialize(pdf, point, options={})

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

@@ -3,9 +3,7 @@
 # Accessors for using a Cell inside a Table.
 
 module Prawn
-  class Table
-
-    # @private
+  class Table    
     class Cell
 
       # This module extends Cell objects when they are used in a table (as
@@ -17,7 +15,7 @@ module Prawn
         # Row number (0-based).
         #
         attr_accessor :row
-
+        
         # Column number (0-based).
         #
         attr_accessor :column

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

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# encoding: utf-8   
 
 # subtable.rb: Yo dawg.
 #
@@ -47,7 +47,7 @@ module Prawn
           @subtable.cells.max_width
         end
 
-        # Proxied to subtable.
+        # Proxied to subtable. 
         #
         def natural_content_height
           @subtable.cells.height

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

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# encoding: utf-8   
 
 # text.rb: Text table cells.
 #
@@ -47,7 +47,7 @@ module Prawn
         # from the final width if the text is long.
         #
         def natural_content_width
-          @natural_content_width ||= [styled_width_of(@content), @pdf.bounds.width].min
+          [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 => spanned_content_width + FPTolerance)
+            b = text_box(:width => content_width + FPTolerance)
             b.render(:dry_run => true)
             b.height + b.line_gap
           end
@@ -64,11 +64,11 @@ module Prawn
         # Draws the text content into its bounding box.
         #
         def draw_content
-          with_font do
+          with_font do 
             @pdf.move_down((@pdf.font.line_gap + @pdf.font.descender)/2)
             with_text_color do
-              text_box(:width => spanned_content_width + FPTolerance,
-                       :height => spanned_content_height + FPTolerance,
+              text_box(:width => content_width + FPTolerance, 
+                       :height => content_height + FPTolerance,
                        :at => [0, @pdf.cursor]).render
             end
           end
@@ -78,11 +78,9 @@ 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.
-          unless defined?(@min_width) && @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
+          min_content_width = [natural_content_width, styled_width_of("M")].min
+          @min_width ||= padding_left + padding_right + min_content_width
+          super
         end
 
         protected
@@ -91,37 +89,27 @@ module Prawn
           @pdf.save_font do
             options = {}
             options[:style] = @text_options[:style] if @text_options[:style]
-            options[:style] ||= @pdf.font.options[:style] if @pdf.font.options[:style]
 
-            @pdf.font(defined?(@font) && @font || @pdf.font.family, options)
+            @pdf.font(@font || @pdf.font.name, options)
 
             yield
           end
         end
 
         def with_text_color
-          if defined?(@text_color) && @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
+          old_color = @pdf.fill_color || '000000'
+          @pdf.fill_color(@text_color) if @text_color
+          yield
+        ensure
+          @pdf.fill_color(old_color)
         end
-
+        
         def text_box(extra_options={})
-          if p = @text_options[:inline_format]
-            p = [] unless p.is_a?(Array)
+          if @text_options[:inline_format]
             options = @text_options.dup
             options.delete(:inline_format)
-            options.merge!(extra_options)
-            options[:document] = @pdf
 
-            array = @pdf.text_formatter.format(@content, *p)
+            array = ::Prawn::Text::Formatted::Parser.to_array(@content)
             ::Prawn::Text::Formatted::Box.new(array,
               options.merge(extra_options).merge(:document => @pdf))
           else
@@ -136,17 +124,6 @@ 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
-          styled_width_of("M")
-        end
       end
     end
   end

data/lib/prawn/table/cells.rb

@@ -8,6 +8,14 @@
 
 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.
     #
@@ -37,8 +45,6 @@ module Prawn
     #
     class Cells < Array
 
-      # @group Experimental API
-
       # Limits selection to the given row or rows. +row_spec+ can be anything
       # that responds to the === operator selecting a set of 0-based row
       # numbers; most commonly a number or a range.
@@ -47,21 +53,14 @@ module Prawn
       #   table.rows(3..4) # selects rows four and five
       #
       def rows(row_spec)
-        index_cells unless defined?(@indexed) && @indexed
-        row_spec = transform_spec(row_spec, @first_row, @row_count)
+        index_cells unless @indexed
+        row_spec = transform_spec(row_spec, @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 defined?(@indexed) && @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,21 +69,14 @@ module Prawn
       #   table.columns(3..4) # selects columns four and five
       #
       def columns(col_spec)
-        index_cells unless defined?(@indexed) && @indexed
-        col_spec = transform_spec(col_spec, @first_column, @column_count)
+        index_cells unless @indexed
+        col_spec = transform_spec(col_spec, @column_count)
         Cells.new(@columns[col_spec] ||= select { |c|
-                    col_spec.respond_to?(:include?) ?
+                    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 defined?(@indexed) && @indexed
-        @column_count
-      end
-
       # Allows you to filter the given cells by arbitrary properties.
       #
       #   table.column(4).filter { |cell| cell.content =~ /Yes/ }.
@@ -96,37 +88,11 @@ module Prawn
 
       # Retrieves a cell based on its 0-based row and column. Returns an
       # individual Cell, not a Cells collection.
-      #
+      # 
       #   table.cells[0, 0].content # => "First cell content"
       #
       def [](row, col)
-        return nil if empty?
-        index_cells unless defined?(@indexed) && @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 defined?(@indexed) && @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
+        find { |c| c.row == row && c.column == col }
       end
 
       # Supports setting multiple properties at once.
@@ -144,42 +110,51 @@ module Prawn
       #   table.cells.style { |cell| cell.border_width += 12 }
       #
       def style(options={}, &block)
-        each do |cell|
-          next if cell.is_a?(Cell::SpanDummy)
-          cell.style(options, &block)
-        end
+        each { |cell| cell.style(options, &block) }
       end
 
       # Returns the total width of all columns in the selected set.
       #
       def width
-        widths = {}
-        each do |cell|
-          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
+        column_widths = {}
+        each do |cell| 
+          column_widths[cell.column] = 
+            [column_widths[cell.column], cell.width].compact.max
         end
-        widths.values.inject(0, &:+)
+        column_widths.values.inject(0) { |sum, width| sum + width }
       end
 
       # Returns minimum width required to contain cells in the set.
       #
       def min_width
-        aggregate_cell_values(:column, :avg_spanned_min_width, :max)
+        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 }
       end
 
       # Returns maximum width that can contain cells in the set.
       #
       def max_width
-        aggregate_cell_values(:column, :max_width_ignoring_span, :max)
+        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 }
       end
 
       # Returns the total height of all rows in the selected set.
       #
       def height
-        aggregate_cell_values(:row, :height_ignoring_span, :max)
+        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 }
       end
 
       # Supports setting arbitrary properties on a group of cells.
@@ -187,21 +162,17 @@ module Prawn
       #   table.cells.row(3..6).background_color = 'cc0000'
       #
       def method_missing(id, *args, &block)
-        if id.to_s =~ /=\z/
-          each { |c| c.send(id, *args, &block) if c.respond_to?(id) }
-        else
-          super
-        end
+        each { |c| c.send(id, *args, &block) }
       end
 
       protected
-
+      
       # Defers indexing until rows() or columns() is actually called on the
       # Cells object. Without this, we would needlessly index the leaf nodes of
       # the object graph, the ones that are only there to be iterated over.
       #
       # Make sure to call this before using @rows or @columns.
-      #
+      # 
       def index_cells
         @rows = {}
         @columns = {}
@@ -214,89 +185,24 @@ 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 = {}
-
-        #calculate values for all cells that do not span accross multiple cells
-        #this ensures that we don't have a problem if the first line includes
-        #a cell that spans across multiple cells
-        each do |cell|
-          #don't take spanned cells
-          if cell.colspan == 1 and cell.class != Prawn::Table::Cell::SpanDummy
-            index = cell.send(row_or_column)
-            values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-          end
-        end
-
-        #if there are only colspanned or rowspanned cells in a table
-        spanned_width_needs_fixing = true
-
-        each do |cell|
-          index = cell.send(row_or_column)
-          if cell.colspan > 1
-            #calculate current (old) return value before we do anything
-            old_sum = 0
-            cell.colspan.times { |i|
-              old_sum += values[index+i] unless values[index+i].nil?
-            }
-
-            #calculate future return value
-            new_sum = cell.send(meth) * cell.colspan
-
-            #due to float rounding errors we need to ignore a small difference in the new 
-            #and the old sum the same had to be done in
-            #the column_width_calculator#natural_width
-            spanned_width_needs_fixing = ((new_sum - old_sum) > Prawn::FLOAT_PRECISION)
-
-            if spanned_width_needs_fixing
-              #not entirely sure why we need this line, but with it the tests pass
-              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-              #overwrite the old values with the new ones, but only if all entries existed
-              entries_exist = true
-              cell.colspan.times { |i| entries_exist = false if values[index+i].nil? }
-              cell.colspan.times { |i|
-                values[index+i] = cell.send(meth) if entries_exist
-              }
-            end
-          else
-            if spanned_width_needs_fixing && cell.class == Prawn::Table::Cell::SpanDummy
-              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-            end
-          end
-        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+. The
-      # first row/column is indicated by +first+; this value is considered row
-      # or column 0.
+      # negative indices to be positive, given a total size of +total+.
       #
-      def transform_spec(spec, first, total)
+      def transform_spec(spec, total)
         case spec
         when Range
-          transform_spec(spec.begin, first, total) ..
-            transform_spec(spec.end, first, total)
+          transform_spec(spec.begin, total)..transform_spec(spec.end, total)
         when Integer
-          spec < 0 ? (first + total + spec) : first + spec
-        when Enumerable
-          spec.map { |x| first + x }
+          spec < 0 ? (total + spec) : spec
         else # pass through
-          raise "Don't understand spec #{spec.inspect}"
+          spec
         end
       end
     end