prawnx 0.1.1

data/lib/prawnx/table/cell.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require "date"
+
+module PrawnX
+  class Document
+    def cell(options = {})
+      cell = Table::Cell.make(self, options.delete(:content), options)
+      cell.draw
+      cell
+    end
+
+    def make_cell(content, options = {})
+      Table::Cell.make(self, content, options)
+    end
+
+    # Runs the block, then puts back the listed attributes as they were.
+    def mask(*fields)
+      stored = fields.to_h { [it, public_send(it)] }
+      yield
+      stored.each { |field, value| public_send(:"#{field}=", value) }
+    end
+  end
+
+  class Table
+    class Cell
+      # Extra width given to a cell's content box, so text measured to fit exactly is not wrapped.
+      FPTolerance = 1
+      SIDE_INDEX = {top: 0, right: 1, bottom: 2, left: 3}.freeze
+
+      attr_reader :padding, :colspan, :rowspan, :dummy_cells, :border_widths, :border_colors, :border_lines
+      attr_writer :height
+      attr_accessor :borders, :content, :background_color
+
+      def self.make(pdf, content, options = {})
+        at = options.delete(:at) || [0, pdf.cursor]
+        content = content.to_s if content.nil? || content.is_a?(Numeric) || content.is_a?(Date)
+        if content.is_a?(Hash)
+          return Cell::Image.new(pdf, at, content) if content[:image]
+
+          options.update(content)
+          content = options[:content]
+        else
+          options[:content] = content
+        end
+        options[:content] = content = "" if content.nil?
+
+        case content
+        when Cell then content
+        when String then Cell::Text.new(pdf, at, options)
+        when Table then Cell::Subtable.new(pdf, at, options)
+        when Array then Cell::Subtable.new(pdf, at, options.merge(content: Table.new(options[:content], pdf, {})))
+        else raise Errors::UnrecognizedTableContent
+        end
+      end
+
+      def self.draw_cells(cells)
+        cells.each do |cell, point|
+          cell.set_width_constraints
+          cell.draw_background(point)
+        end
+        cells.each do |cell, point|
+          cell.draw_borders(point)
+          cell.draw_bounded_content(point)
+        end
+      end
+
+      def initialize(pdf, point, options = {})
+        @pdf = pdf
+        @point = point
+        @padding = [5, 5, 5, 5]
+        @borders = %i[top bottom left right]
+        @border_widths = [1] * 4
+        @border_colors = ["000000"] * 4
+        @border_lines = [:solid] * 4
+        @colspan = 1
+        @rowspan = 1
+        @dummy_cells = []
+        options.each { |key, value| send(:"#{key}=", value) }
+        @initializer_run = true
+      end
+
+      def min_width_ignoring_span
+        set_width_constraints
+        @min_width
+      end
+
+      def min_width
+        return min_width_ignoring_span if @colspan == 1
+
+        min_widths = Hash.new(0)
+        dummy_cells.each { min_widths[it.column] = [min_widths[it.column], it.min_width].max }
+        min_widths[column] = [min_widths[column], min_width_ignoring_span].max
+        min_widths.values.inject(0, :+)
+      end
+
+      def avg_spanned_min_width
+        min_width.to_f / colspan
+      end
+
+      def max_width_ignoring_span
+        set_width_constraints
+        @max_width
+      end
+
+      def max_width
+        return max_width_ignoring_span if @colspan == 1
+
+        max_widths = Hash.new(0)
+        dummy_cells.each { max_widths[it.column] = [max_widths[it.column], it.max_width].min }
+        max_widths[column] = [max_widths[column], max_width_ignoring_span].min
+        max_widths.values.inject(0, :+)
+      end
+
+      def style(options = {}, &block)
+        options.each { |key, value| send(:"#{key}=", value) if respond_to?(:"#{key}=") }
+        block&.call(self)
+      end
+
+      def width_ignoring_span
+        @width || (content_width + padding_left + padding_right)
+      end
+
+      def width
+        return width_ignoring_span if @colspan == 1 && @rowspan == 1
+
+        column_widths = Hash.new(0)
+        dummy_cells.each { column_widths[it.column] = [column_widths[it.column], it.width].max }
+        column_widths[column] = [column_widths[column], width_ignoring_span].max
+        column_widths.values.inject(0, :+)
+      end
+
+      def width=(width)
+        @width = @min_width = @max_width = width
+      end
+
+      def content_width
+        return @width - padding_left - padding_right if @width
+
+        natural_content_width
+      end
+
+      def spanned_content_width
+        width - padding_left - padding_right
+      end
+
+      def natural_content_width
+        raise NotImplementedError, "subclasses must implement natural_content_width"
+      end
+
+      def height_ignoring_span
+        @height || (content_height + padding_top + padding_bottom)
+      end
+
+      def height
+        return height_ignoring_span if @colspan == 1 && @rowspan == 1
+
+        row_heights = Hash.new(0)
+        dummy_cells.each { row_heights[it.row] = [row_heights[it.row], it.height].max }
+        row_heights[row] = [row_heights[row], height_ignoring_span].max
+        row_heights.values.inject(0, :+)
+      end
+
+      def content_height
+        return @height - padding_top - padding_bottom if @height
+
+        natural_content_height
+      end
+
+      def spanned_content_height
+        height - padding_top - padding_bottom
+      end
+
+      def natural_content_height
+        raise NotImplementedError, "subclasses must implement natural_content_height"
+      end
+
+      def colspan=(span)
+        raise Errors::InvalidTableSpan, "colspan must be provided in the table's structure, never in the initialization block. See Prawn's documentation for details." if @initializer_run
+
+        @colspan = span
+      end
+
+      def rowspan=(span)
+        raise Errors::InvalidTableSpan, "rowspan must be provided in the table's structure, never in the initialization block. See Prawn's documentation for details." if @initializer_run
+
+        @rowspan = span
+      end
+
+      def draw(point = [x, y])
+        Cell.draw_cells([[self, point]])
+      end
+
+      def draw_bounded_content(point)
+        @pdf.float do
+          @pdf.bounding_box([point[0] + padding_left, point[1] - padding_top],
+            width: spanned_content_width + FPTolerance, height: spanned_content_height + FPTolerance) { draw_content }
+        end
+      end
+
+      def x
+        @point[0]
+      end
+
+      def x=(value)
+        @point[0] = value
+      end
+
+      def relative_x
+        x + @pdf.bounds.left_side - @pdf.bounds.absolute_left
+      end
+
+      def y
+        @point[1]
+      end
+
+      def y=(value)
+        @point[1] = value
+      end
+
+      def relative_y(offset = 0)
+        y + offset - @pdf.bounds.absolute_bottom
+      end
+
+      def padding=(padding)
+        @padding = four_sides(padding, nil => [0, 0, 0, 0], Numeric => [padding] * 4) do
+          raise ArgumentError, ":padding must be a number or an array [v,h] or [t,r,b,l]"
+        end
+      end
+
+      %i[top right bottom left].each_with_index do |side, index|
+        define_method(:"padding_#{side}") { @padding[index] }
+        define_method(:"padding_#{side}=") { |value| @padding[index] = value }
+        define_method(:"border_#{side}_color") { @border_colors[index] }
+        define_method(:"border_#{side}_color=") { |value| @border_colors[index] = value }
+        define_method(:"border_#{side}_width") { @borders.include?(side) ? @border_widths[index] : 0 }
+        define_method(:"border_#{side}_width=") { |value| @border_widths[index] = value }
+        define_method(:"border_#{side}_line") { @borders.include?(side) ? @border_lines[index] : 0 }
+        define_method(:"border_#{side}_line=") { |value| @border_lines[index] = value }
+      end
+
+      def border_color=(color)
+        @border_colors = four_sides(color, nil => ["000000"] * 4, String => [color] * 4) do
+          raise ArgumentError, ":border_color must be a string or an array [v,h] or [t,r,b,l]"
+        end
+      end
+      alias border_colors= border_color=
+
+      # Prawn-table resets a nil border width to four "000000": kept for compatibility.
+      def border_width=(width)
+        @border_widths = four_sides(width, nil => ["000000"] * 4, Numeric => [width] * 4) do
+          raise ArgumentError, ":border_width must be a string or an array [v,h] or [t,r,b,l]"
+        end
+      end
+      alias border_widths= border_width=
+
+      def border_line=(line)
+        @border_lines =
+          if line.nil? then [:solid] * 4
+          elsif line.length == 1 then [line[0]] * 4
+          else four_sides(line) { raise ArgumentError, "border_line must be one of :solid, :dashed, :dotted or an array [v,h] or [t,r,b,l]" }
+          end
+      end
+      alias border_lines= border_line=
+
+      def set_width_constraints
+        @min_width ||= padding_left + padding_right
+        @max_width ||= @pdf.bounds.width
+      end
+
+      def draw_background(point)
+        return unless background_color
+
+        @pdf.mask(:fill_color) do
+          @pdf.fill_color background_color
+          @pdf.fill_rectangle point, width, height
+        end
+      end
+
+      def draw_borders(point)
+        x, y = point
+        @pdf.mask(:line_width, :stroke_color) do
+          @borders.each do |border|
+            index = SIDE_INDEX[border]
+            border_width = @border_widths[index]
+            next if border_width <= 0
+
+            from, to =
+              case border
+              when :top then [[x, y], [x + width, y]]
+              when :bottom then [[x, y - height], [x + width, y - height]]
+              when :left then [[x, y + (border_top_width / 2.0)], [x, y - height - (border_bottom_width / 2.0)]]
+              when :right then [[x + width, y + (border_top_width / 2.0)], [x + width, y - height - (border_bottom_width / 2.0)]]
+              end
+            case @border_lines[index]
+            when :dashed then @pdf.dash border_width * 4
+            when :dotted then @pdf.dash border_width, space: border_width * 2
+            when :solid then nil
+            else raise ArgumentError, "border_line must be :solid, :dotted or :dashed"
+            end
+            @pdf.line_width = border_width
+            @pdf.stroke_color = @border_colors[index]
+            @pdf.stroke_line(from, to)
+            @pdf.undash if @pdf.dashed?
+          end
+        end
+      end
+
+      def draw_content
+        raise NotImplementedError, "subclasses must implement draw_content"
+      end
+
+      private
+
+      # A value for each side, CSS style: one for all, [vertical, horizontal], [top, horizontal, bottom] or four.
+      def four_sides(value, special_cases = {})
+        special_cases.each { |kind, sides| return sides if kind.nil? ? value.nil? : kind === value }
+        case value.length
+        when 2 then [value[0], value[1], value[0], value[1]]
+        when 3 then [value[0], value[1], value[2], value[1]]
+        when 4 then [value[0], value[1], value[2], value[3]]
+        else yield
+        end
+      end
+
+      module InTable
+        attr_accessor :row, :column
+      end
+    end
+  end
+end

data/lib/prawnx/table/cells.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module PrawnX
+  class Table
+    # A selection of a table's cells, addressable by row and column, styled all at once.
+    class Cells < Array
+      def fits_on_current_page?(offset, reference_bounds)
+        return true if empty?
+
+        height_with_span < (self[0, 0].y + offset) - reference_bounds.absolute_bottom
+      end
+
+      def rows(row_spec)
+        index_cells unless @indexed
+        row_spec = transform_spec(row_spec, @first_row, @row_count)
+        Cells.new(@rows[row_spec] ||= select { row_spec.respond_to?(:include?) ? row_spec.include?(it.row) : row_spec === it.row })
+      end
+      alias row rows
+
+      def row_count
+        index_cells unless @indexed
+        @row_count
+      end
+
+      def columns(column_spec)
+        index_cells unless @indexed
+        column_spec = transform_spec(column_spec, @first_column, @column_count)
+        Cells.new(@columns[column_spec] ||= select { column_spec.respond_to?(:include?) ? column_spec.include?(it.column) : column_spec === it.column })
+      end
+      alias column columns
+
+      def column_count
+        index_cells unless @indexed
+        @column_count
+      end
+
+      def filter(&)
+        Cells.new(select(&))
+      end
+
+      def [](row, column)
+        return nil if empty?
+
+        index_cells unless @indexed
+        row_cells = @rows[@first_row + row] || []
+        column_cells = @columns[@first_column + column] || []
+        if row_cells.length < column_cells.length
+          row_cells.find { it.column == @first_column + column }
+        else
+          column_cells.find { it.row == @first_row + row }
+        end
+      end
+
+      def []=(row, column, cell)
+        cell.extend(Cell::InTable)
+        cell.row = row
+        cell.column = column
+        if @indexed
+          (@rows[row] ||= []) << cell
+          (@columns[column] ||= []) << cell
+          @first_row = row if !@first_row || row < @first_row
+          @first_column = column if !@first_column || column < @first_column
+          @row_count = @rows.size
+          @column_count = @columns.size
+        end
+        self << cell
+      end
+
+      def style(options = {}, &)
+        each { it.style(options, &) unless it.is_a?(Cell::SpanDummy) }
+      end
+
+      def width
+        ColumnWidthCalculator.new(self).natural_widths.inject(0, :+)
+      end
+
+      def min_width
+        aggregate_cell_values(:column, :avg_spanned_min_width, :max)
+      end
+
+      def max_width
+        aggregate_cell_values(:column, :max_width_ignoring_span, :max)
+      end
+
+      def height
+        aggregate_cell_values(:row, :height_ignoring_span, :max)
+      end
+
+      def height_with_span
+        aggregate_cell_values(:row, :height, :max)
+      end
+
+      # Setters reach every cell that has them: cells.background_color = "eeeeee".
+      def method_missing(name, *arguments, &)
+        return super unless name.end_with?("=")
+
+        each { it.public_send(name, *arguments, &) if it.respond_to?(name) }
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        name.end_with?("=") || super
+      end
+
+      protected
+
+      def index_cells
+        @rows = {}
+        @columns = {}
+        each do |cell|
+          (@rows[cell.row] ||= []) << cell
+          (@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
+
+      def aggregate_cell_values(row_or_column, method, aggregate)
+        ColumnWidthCalculator.new(self).aggregate_cell_values(row_or_column, method, aggregate)
+      end
+
+      def transform_spec(spec, first, total)
+        case spec
+        when Range then transform_spec(spec.begin, first, total)..transform_spec(spec.end, first, total)
+        when Integer then spec.negative? ? first + total + spec : first + spec
+        when Enumerable then spec.map { first + it }
+        else raise "Don't understand spec #{spec.inspect}"
+        end
+      end
+    end
+
+    # Widths of columns, and sums of per-row or per-column cell values, accounting for cells spanning several.
+    class ColumnWidthCalculator
+      def initialize(cells)
+        @cells = cells
+        @widths_by_column = Hash.new(0)
+        @rows_with_a_span_dummy = Hash.new(false)
+        @cells.each { @rows_with_a_span_dummy[it.row] = true if it.is_a?(Cell::SpanDummy) }
+      end
+
+      def has_a_span_dummy?(row)
+        @rows_with_a_span_dummy[row]
+      end
+
+      def fill_values_if_needed(values, cell, index, method)
+        missing_count = cell.colspan.times.count { values[index + it].nil? }
+        return values if missing_count.zero? || missing_count == cell.colspan || !has_a_span_dummy?(cell.row)
+
+        new_sum = cell.send(method) * cell.colspan
+        cell.colspan.times { new_sum -= values[index + it] unless values[index + it].nil? }
+        new_value = new_sum.to_f / missing_count
+        cell.colspan.times { values[index + it] = new_value if values[index + it].nil? }
+        values
+      end
+
+      def natural_widths
+        @cells.each do |cell|
+          @widths_by_column[cell.column] = [@widths_by_column[cell.column], cell.width.to_f].max unless has_a_span_dummy?(cell.row)
+        end
+        @cells.each do |cell|
+          next unless has_a_span_dummy?(cell.row)
+          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
+            current_width_of_spanned_cells = @widths_by_column.to_a[cell.column..(cell.column + cell.colspan - 1)].map(&:last).inject(0, :+)
+            if (cell.width.to_f - current_width_of_spanned_cells) > FLOAT_PRECISION
+              cell.colspan.times { @widths_by_column[cell.column + it] = cell.width.to_f / cell.colspan }
+            end
+          end
+        end
+        @widths_by_column.sort_by { |column, _| column }.map { |_, width| width }
+      end
+
+      def aggregate_cell_values(row_or_column, method, aggregate)
+        values = {}
+        @cells.each do |cell|
+          next unless cell.colspan == 1 && cell.class != Cell::SpanDummy
+
+          index = cell.send(row_or_column)
+          values[index] = [values[index], cell.send(method)].compact.send(aggregate)
+        end
+
+        spanned_width_needs_fixing = true
+        @cells.each do |cell|
+          index = cell.send(row_or_column)
+          if cell.colspan > 1
+            values = fill_values_if_needed(values, cell, index, method) if row_or_column == :column
+            old_sum = cell.colspan.times.inject(0) { |sum, offset| values[index + offset] ? sum + values[index + offset] : sum }
+            new_sum = cell.send(method) * cell.colspan
+            spanned_width_needs_fixing = (new_sum - old_sum) > FLOAT_PRECISION
+            if spanned_width_needs_fixing
+              values[index] = [values[index], cell.send(method)].compact.send(aggregate)
+              entries_exist = cell.colspan.times.none? { values[index + it].nil? }
+              cell.colspan.times { values[index + it] = cell.send(method) if entries_exist }
+            end
+          elsif spanned_width_needs_fixing && cell.class == Cell::SpanDummy
+            values[index] = [values[index], cell.send(method)].compact.send(aggregate)
+          end
+        end
+        values.values.inject(0, :+)
+      end
+    end
+  end
+end