gamba 2.0.0

data/lib/gamba/table/cells.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Prawn
+  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 { |cell| row_spec.respond_to?(:include?) ? row_spec.include?(cell.row) : row_spec === cell.row })
+      end
+      alias_method :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 { |cell| column_spec.respond_to?(:include?) ? column_spec.include?(cell.column) : column_spec === cell.column })
+      end
+      alias_method :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 { _1.column == @first_column + column }
+        else
+          column_cells.find { _1.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 { |cell| cell.style(options, &) unless cell.is_a?(Cell::SpanDummy) }
+      end
+
+      def width
+        ColumnWidthCalculator.new(self).natural_widths.sum
+      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 { |cell| cell.public_send(name, *arguments, &) if cell.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 + _1 }
+        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 { |cell| @rows_with_a_span_dummy[cell.row] = true if cell.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 { |offset| values[index + offset].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 { |offset| new_sum -= values[index + offset] unless values[index + offset].nil? }
+        new_value = new_sum.to_f / missing_count
+        cell.colspan.times { |offset| values[index + offset] = new_value if values[index + offset].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)].sum(&:last)
+            if (cell.width.to_f - current_width_of_spanned_cells) > FLOAT_PRECISION
+              cell.colspan.times { |offset| @widths_by_column[cell.column + offset] = 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? { |offset| values[index + offset].nil? }
+              cell.colspan.times { |offset| values[index + offset] = cell.send(method) if entries_exist }
+            end
+          elsif spanned_width_needs_fixing && cell.instance_of?(Cell::SpanDummy)
+            values[index] = [values[index], cell.send(method)].compact.send(aggregate)
+          end
+        end
+        values.values.sum
+      end
+    end
+  end
+end

data/lib/gamba/table.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Errors
+    InvalidTableData = Class.new(StandardError)
+    EmptyTable = Class.new(StandardError)
+  end
+
+  # A table of cells laid out in rows and columns, sized to its content, drawn across pages with its header
+  # repeated: prawn-table's API.
+  class Table
+    module Interface
+      def table(data, options = {}, &)
+        table = Table.new(data, self, options, &)
+        table.draw
+        table
+      end
+
+      def make_table(data, options = {}, &)
+        Table.new(data, self, options, &)
+      end
+    end
+
+    attr_reader :row_length, :column_length, :cells
+    attr_writer :width, :position, :header, :row_colors
+
+    def initialize(data, document, options = {}, &block)
+      @pdf = document
+      @cells = make_cells(data)
+      @header = false
+      options.each { |key, value| send(:"#{key}=", value) }
+      if block
+        (block.arity < 1) ? instance_eval(&block) : yield(self)
+      end
+      set_column_widths
+      set_row_heights
+      position_cells
+    end
+
+    def before_rendering_page(&block)
+      @before_rendering_page = block
+    end
+
+    def width
+      @width ||= [natural_width, @pdf.bounds.width].min
+    end
+
+    def column_widths=(widths)
+      case widths
+      when Array then widths.each_with_index { |width, index| column(index).width = width }
+      when Hash then widths.each { |index, width| column(index).width = width }
+      when Numeric then cells.width = widths
+      else raise ArgumentError, "cannot interpret column widths"
+      end
+    end
+
+    def height
+      cells.height
+    end
+
+    def cell_style=(style_hash)
+      cells.style(style_hash)
+    end
+
+    def style(stylable, style_hash = {}, &)
+      stylable.style(style_hash, &)
+    end
+
+    def rows(row_spec)
+      cells.rows(row_spec)
+    end
+    alias_method :row, :rows
+
+    def columns(column_spec)
+      cells.columns(column_spec)
+    end
+    alias_method :column, :columns
+
+    def draw
+      with_position do
+        reference_bounds = @pdf.reference_bounds
+        started_new_page_at_row = initial_row_on_initial_page
+        offset = @pdf.y
+        @header_row = header_rows if @header
+        cells_this_page = []
+        @cells.each do |cell|
+          if start_new_page?(cell, offset, reference_bounds)
+            cells_this_page, offset = ink_and_draw_cells_and_start_new_page(cells_this_page, cell)
+            started_new_page_at_row = cell.row
+          end
+          cell = set_background_color(cell, started_new_page_at_row)
+          cells_this_page << [cell, [cell.relative_x, cell.relative_y(offset)]]
+        end
+        ink_and_draw_cells(cells_this_page)
+        @pdf.move_cursor_to(@cells.last.relative_y(offset) - @cells.last.height)
+      end
+    end
+
+    def column_widths
+      @column_widths ||= begin
+        if width - cells.min_width < -FLOAT_PRECISION
+          raise Errors::CannotFit, "Table's width was set too small to contain its contents (min width #{cells.min_width}, requested #{width})"
+        end
+        if width - cells.max_width > FLOAT_PRECISION
+          raise Errors::CannotFit, "Table's width was set larger than its contents' maximum width (max width #{cells.max_width}, requested #{width})"
+        end
+
+        if width - natural_width < -FLOAT_PRECISION
+          ratio = (width - cells.min_width).to_f / (natural_width - cells.min_width)
+          (0...column_length).map do |index|
+            minimum = column(index).min_width
+            (ratio * (natural_column_widths[index] - minimum)) + minimum
+          end
+        elsif width - natural_width > FLOAT_PRECISION
+          ratio = (width - cells.width).to_f / (cells.max_width - cells.width)
+          (0...column_length).map do |index|
+            natural = natural_column_widths[index]
+            (ratio * (column(index).max_width - natural)) + natural
+          end
+        else
+          natural_column_widths
+        end
+      end
+    end
+
+    def row_heights
+      @natural_row_heights ||= begin
+        heights_by_row = Hash.new(0)
+        cells.each do |cell|
+          next if cell.is_a?(Cell::SpanDummy)
+
+          height_per_row = cell.height.to_f / cell.rowspan
+          cell.rowspan.times { |offset| heights_by_row[cell.row + offset] = [heights_by_row[cell.row + offset], height_per_row].max }
+        end
+        heights_by_row.sort_by { |row, _| row }.map { |_, height| height }
+      end
+    end
+
+    protected
+
+    def set_background_color(cell, started_new_page_at_row)
+      if @row_colors && (!@header || cell.row.positive?)
+        index = cell.row - [started_new_page_at_row, number_of_header_rows].max
+        cell.background_color ||= @row_colors[index % @row_colors.length]
+      end
+      cell
+    end
+
+    def number_of_header_rows
+      return @header if @header.is_a?(Integer)
+
+      @header ? 1 : 0
+    end
+
+    def start_new_page?(cell, offset, reference_bounds)
+      cell.column.zero? && cell.row.positive? && !row(cell.row).fits_on_current_page?(offset, reference_bounds)
+    end
+
+    def ink_and_draw_cells(cells_this_page, draw_cells = true)
+      ink_cells(cells_this_page)
+      Cell.draw_cells(cells_this_page) if draw_cells
+    end
+
+    def ink_and_draw_cells_and_start_new_page(cells_this_page, cell)
+      ink_and_draw_cells(cells_this_page, @header_row.nil? || cells_this_page.size > @header_row.size)
+      @pdf.bounds.move_past_bottom
+      offset = @pdf.y - cell.y
+      cells_next_page = []
+      offset -= add_header(cell.row, cells_next_page)
+      [cells_next_page, offset]
+    end
+
+    def ink_cells(cells_this_page)
+      @before_rendering_page&.call(Cells.new(cells_this_page.map(&:first)))
+    end
+
+    def initial_row_on_initial_page
+      return 0 if fits_on_page?(@pdf.bounds.height)
+      return -1 if fits_on_page?(row(0..number_of_header_rows).height, true)
+
+      @pdf.bounds.move_past_bottom
+      0
+    end
+
+    def fits_on_page?(needed_height, use_reference_bounds = false)
+      bounds = use_reference_bounds ? @pdf.reference_bounds : @pdf.bounds
+      needed_height < @pdf.y - (bounds.absolute_bottom - FLOAT_PRECISION)
+    end
+
+    def header_rows
+      header_rows = Cells.new
+      number_of_header_rows.times do |row_index|
+        row(row_index).each { |cell| header_rows[cell.row, cell.column] = cell.dup }
+      end
+      header_rows
+    end
+
+    def make_cells(data)
+      assert_proper_table_data(data)
+      cells = Cells.new
+      data.each_with_index do |row_cells, row_number|
+        column_number = 0
+        row_cells.each do |cell_data|
+          column_number += 1 until cells[row_number, column_number].nil?
+          cell = Cell.make(@pdf, cell_data)
+          cells[row_number, column_number] = cell
+          cell.rowspan.times do |row_offset|
+            cell.colspan.times do |column_offset|
+              next if row_offset.zero? && column_offset.zero?
+              if cells[row_number + row_offset, column_number + column_offset]
+                raise Errors::InvalidTableSpan, "Spans overlap at row #{row_number + row_offset}, column #{column_number + column_offset}."
+              end
+
+              dummy = Cell::SpanDummy.new(@pdf, cell)
+              cells[row_number + row_offset, column_number + column_offset] = dummy
+              cell.dummy_cells << dummy
+            end
+          end
+          column_number += cell.colspan
+        end
+      end
+      @row_length = cells.map { |cell| cell.row + cell.rowspan }.max
+      @column_length = cells.map { |cell| cell.column + cell.colspan }.max
+      cells
+    end
+
+    def add_header(row_number, cells_this_page)
+      x_offset = @pdf.bounds.left_side - @pdf.bounds.absolute_left
+      header_height = 0
+      if row_number.positive? && @header
+        y = @pdf.cursor
+        number_of_header_rows.times do |header_index|
+          header_height += add_one_header_row(cells_this_page, x_offset, y - header_height, row_number - 1, header_index)
+        end
+      end
+      header_height
+    end
+
+    def add_one_header_row(page_of_cells, x_offset, y, row, row_of_header = nil)
+      rows_to_operate_on = row_of_header ? @header_row.rows(row_of_header) : @header_row
+      rows_to_operate_on.each do |cell|
+        cell.row = row
+        cell.dummy_cells.each { |dummy| (cell.rowspan > 1) ? dummy.row += row : dummy.row = row }
+        page_of_cells << [cell, [cell.x + x_offset, y]]
+      end
+      rows_to_operate_on.height
+    end
+
+    def assert_proper_table_data(data)
+      if data.nil? || data.empty?
+        raise Errors::EmptyTable, "data must be a non-empty, non-nil, two dimensional array of cell-convertible objects"
+      end
+      raise Errors::InvalidTableData, "data must be a two dimensional array of cellable objects" unless data.all?(Array)
+    end
+
+    def natural_column_widths
+      @natural_column_widths ||= ColumnWidthCalculator.new(cells).natural_widths
+    end
+
+    def natural_width
+      @natural_width ||= natural_column_widths.sum
+    end
+
+    def set_column_widths
+      column_widths.each_with_index { |width, index| column(index).width = width }
+    end
+
+    def set_row_heights
+      row_heights.each_with_index { |height, index| row(index).height = height }
+    end
+
+    def position_cells
+      column_widths.each_with_object([0]) { |width, positions| positions << (positions.last + width) }[0..-2]
+        .each_with_index { |x, index| column(index).x = x }
+      row_heights.each_with_object([0]) { |height, positions| positions << (positions.last - height) }[0..-2]
+        .each_with_index { |y, index| row(index).y = y }
+    end
+
+    def with_position
+      x =
+        case @position || :left
+        when :left then return yield
+        when :center then (@pdf.bounds.width - width) / 2.0
+        when :right then @pdf.bounds.width - width
+        when Numeric then @position
+        else raise ArgumentError, "unknown position #{@position.inspect}"
+        end
+      dy = @pdf.bounds.absolute_top - @pdf.y
+      final_y = nil
+      @pdf.bounding_box([x, @pdf.bounds.top], width:) do
+        @pdf.move_down dy
+        yield
+        final_y = @pdf.y
+      end
+      @pdf.y = final_y
+    end
+  end
+end

data/lib/gamba/text/box.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    # A text box of plain text: what does not fit comes back as a string.
+    class Box < Formatted::Box
+      def initialize(string, options = {})
+        super([{text: string}], options)
+      end
+
+      def render(flags = {})
+        super.map { _1[:text] }.join
+      end
+    end
+  end
+end