prawn-table-continued 1.0.0.rc1

data/lib/prawn/table/cells.rb

@@ -0,0 +1,261 @@
+# encoding: utf-8
+
+# cells.rb: Methods for accessing rows, columns, and cells of a Prawn::Table.
+#
+# Copyright December 2009, Brad Ediger. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module Prawn
+  class Table
+    # Selects the given rows (0-based) for styling. Returns a Cells object --
+    # see the documentation on Cells for things you can do with cells.
+    #
+    def rows(row_spec)
+      cells.rows(row_spec)
+    end
+    alias_method :row, :rows
+
+    # Selects the given columns (0-based) for styling. Returns a Cells object
+    # -- see the documentation on Cells for things you can do with cells.
+    #
+    def columns(col_spec)
+      cells.columns(col_spec)
+    end
+    alias_method :column, :columns
+
+    # Represents a selection of cells to be styled. Operations on a CellProxy
+    # can be chained, and cell properties can be set one-for-all on the proxy.
+    #
+    # To set vertical borders only:
+    #
+    #   table.cells.borders = [:left, :right]
+    #
+    # To highlight a rectangular area of the table:
+    #
+    #   table.rows(1..3).columns(2..4).background_color = 'ff0000'
+    #
+    class Cells < Array
+
+      def fits_on_current_page?(offset, ref_bounds)
+        # an empty row array means it definitely fits
+        return true if self.empty?
+
+        height_with_span < (self[0,0].y + offset) - ref_bounds.absolute_bottom
+      end
+
+      # @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.
+      #
+      #   table.row(0)     # selects first row
+      #   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)
+        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.
+      #
+      #   table.column(0)     # selects first column
+      #   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)
+        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 defined?(@indexed) && @indexed
+        @column_count
+      end
+
+      # Allows you to filter the given cells by arbitrary properties.
+      #
+      #   table.column(4).filter { |cell| cell.content =~ /Yes/ }.
+      #     background_color = '00ff00'
+      #
+      def filter(&block)
+        Cells.new(select(&block))
+      end
+
+      # 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
+      end
+
+      # Supports setting multiple properties at once.
+      #
+      #   table.cells.style(:padding => 0, :border_width => 2)
+      #
+      # is the same as:
+      #
+      #   table.cells.padding = 0
+      #   table.cells.border_width = 2
+      #
+      # You can also pass a block, which will be called for each cell in turn.
+      # This allows you to set more complicated properties:
+      #
+      #   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
+      end
+
+      # Returns the total width of all columns in the selected set.
+      #
+      def width
+        ColumnWidthCalculator.new(self).natural_widths.inject(0, &:+)
+      end
+
+      # Returns minimum width required to contain cells in the set.
+      #
+      def min_width
+        aggregate_cell_values(:column, :avg_spanned_min_width, :max)
+      end
+
+      # Returns maximum width that can contain cells in the set.
+      #
+      def max_width
+        aggregate_cell_values(:column, :max_width_ignoring_span, :max)
+      end
+
+      # Returns the total height of all rows in the selected set.
+      #
+      def height
+        aggregate_cell_values(:row, :height_ignoring_span, :max)
+      end
+
+      # Returns the total height of all rows in the selected set
+      # including spanned cells if the cell is the master cell
+      #
+      def height_with_span
+        aggregate_cell_values(:row, :height, :max)
+      end
+
+      # Supports setting arbitrary properties on a group of cells.
+      #
+      #   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
+      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 = {}
+
+        each do |cell|
+          @rows[cell.row] ||= []
+          @rows[cell.row] << cell
+
+          @columns[cell.column] ||= []
+          @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)
+        ColumnWidthCalculator.new(self).aggregate_cell_values(row_or_column, meth, aggregate)
+      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.
+      #
+      def transform_spec(spec, first, total)
+        case spec
+        when Range
+          transform_spec(spec.begin, first, total) ..
+            transform_spec(spec.end, first, total)
+        when Integer
+          spec < 0 ? (first + total + spec) : first + spec
+        when Enumerable
+          spec.map { |x| first + x }
+        else # pass through
+          raise "Don't understand spec #{spec.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/prawn/table/column_width_calculator.rb

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+module Prawn
+  class Table
+    # @private
+    class ColumnWidthCalculator
+      def initialize(cells)
+        @cells = cells
+
+        @widths_by_column        = Hash.new(0)
+        @rows_with_a_span_dummy  = Hash.new(false)
+
+        #calculate for each row if it includes a Cell:SpanDummy
+        @cells.each do |cell|
+          @rows_with_a_span_dummy[cell.row] = true if cell.is_a?(Cell::SpanDummy)
+        end
+      end
+
+      # does this row include a Cell:SpanDummy?
+      #
+      # @param row - the row that should be checked for Cell:SpanDummy elements
+      #
+      def has_a_span_dummy?(row)
+        @rows_with_a_span_dummy[row]
+      end
+
+      # helper method
+      # column widths are stored in the values array
+      # a cell may span cells whose value is only partly given
+      # this function handles this special case
+      #
+      # @param values - The columns widths calculated up until now
+      # @param cell - The current cell
+      # @param index - The current column
+      # @param meth - Meth (min/max); used to calculate values to be filled
+      #
+      def fill_values_if_needed(values, cell, index, meth)
+        #have all spanned indices been filled with a value?
+        #e.g. values[0], values[1] and values[2] don't return nil given a index of 0 and a colspan of 3
+        number_of_nil_values = 0
+        cell.colspan.times do |i|
+          number_of_nil_values += 1 if values[index+i].nil?
+        end
+
+        #nothing to do? because
+        #a) all values are filled
+        return values if number_of_nil_values == 0
+        #b) no values are filled
+        return values if number_of_nil_values == cell.colspan
+        #c) I am not sure why this line is needed FIXXME
+        #some test cases manage to this line even though there is no dummy cell in the row
+        #I'm not sure if this is a sign for a further underlying bug.
+        return values unless has_a_span_dummy?(cell.row)
+        #fill up the values array
+
+        #calculate the new sum
+        new_sum = cell.send(meth) * cell.colspan
+        #substract any calculated values
+        cell.colspan.times do |i|
+          new_sum -= values[index+i] unless values[index+i].nil?
+        end
+
+        #calculate value for the remaining - not yet filled - cells.
+        new_value = new_sum.to_f / number_of_nil_values
+        #fill the not yet filled cells
+        cell.colspan.times do |i|
+          values[index+i] = new_value if values[index+i].nil?
+        end
+        return values
+      end
+
+      def natural_widths
+        #calculate natural column width for all rows that do not include a span dummy
+        @cells.each do |cell|
+          unless has_a_span_dummy?(cell.row)
+            @widths_by_column[cell.column] =
+              [@widths_by_column[cell.column], cell.width.to_f].max
+          end
+        end
+
+        #integrate natural column widths for all rows that do include a span dummy
+        @cells.each do |cell|
+          next unless has_a_span_dummy?(cell.row)
+          #the width of a SpanDummy cell will be calculated by the "mother" cell
+          next if cell.is_a?(Cell::SpanDummy)
+
+          if cell.colspan == 1
+            @widths_by_column[cell.column] =
+              [@widths_by_column[cell.column], cell.width.to_f].max
+          else
+            #calculate the current with of all cells that will be spanned by the current cell
+            current_width_of_spanned_cells =
+              @widths_by_column.to_a[cell.column..(cell.column + cell.colspan - 1)]
+                               .collect{|key, value| value}.inject(0, :+)
+
+            #update the Hash only if the new with is at least equal to the old one
+            #due to arithmetic errors we need to ignore a small difference in the new and the old sum
+            #the same had to be done in the column_widht_calculator#natural_width
+            update_hash = ((cell.width.to_f - current_width_of_spanned_cells) >
+                           Prawn::FLOAT_PRECISION)
+
+            if update_hash
+              # Split the width of colspanned cells evenly by columns
+              width_per_column = cell.width.to_f / cell.colspan
+              # Update the Hash
+              cell.colspan.times do |i|
+                @widths_by_column[cell.column + i] = width_per_column
+              end
+            end
+          end
+        end
+
+        @widths_by_column.sort_by { |col, _| col }.map { |_, w| w }
+      end
+
+      # get column widths (either min or max depending on meth)
+      # used in cells.rb
+      #
+      # @param row_or_column - you may call this on either rows or columns
+      # @param meth - min/max
+      # @param aggregate - functions from cell.rb to be used to aggregate e.g. avg_spanned_min_width
+      #
+      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
+        @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
+
+        @cells.each do |cell|
+          index = cell.send(row_or_column)
+          if cell.colspan > 1
+            #special treatment if some but not all spanned indices in the values array have been calculated
+            #only applies to rows
+            values = fill_values_if_needed(values, cell, index, meth) if row_or_column == :column
+            #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
+
+        return values.values.inject(0, &:+)
+      end
+    end
+
+  end
+end

data/lib/prawn/table/version.rb

@@ -0,0 +1,5 @@
+module Prawn
+  class Table
+    VERSION = '1.0.0.rc1'.freeze
+  end
+end