receipts 2.4.0 → 3.0.0

data/lib/receipts/pdf/table.rb

@@ -0,0 +1,250 @@
+module Receipts
+  module PDF
+    # Simple tables with text cells, borders, padding and automatic column widths.
+    #
+    #   table(data, width: bounds.width, column_widths: [200, nil, 100], header: true,
+    #     cell_style: {padding: 6, borders: [:bottom], border_color: "eeeeee", inline_format: true}) do
+    #     row(0).font_style = :bold
+    #     column(-1).align = :right
+    #   end
+    #
+    # Cells may be strings, nil, or hashes with :content and cell options.
+    class Table
+      class Cell
+        attr_accessor :borders, :border_color, :border_width, :align, :font_style,
+          :size, :text_color, :background_color, :inline_format, :font, :leading
+        attr_reader :content, :padding
+
+        def initialize(document, options = {})
+          @document = document
+          @content = ""
+          @padding = [5, 5, 5, 5]
+          @borders = [:top, :right, :bottom, :left]
+          @border_color = "000000"
+          @border_width = 1
+          @align = :left
+          @inline_format = false
+          @leading = 0
+          options.each { |key, value| public_send(:"#{key}=", value) }
+        end
+
+        def content=(value)
+          @content = value.to_s
+        end
+
+        def padding=(value)
+          @padding = Geometry.expand_box(value)
+        end
+
+        def horizontal_padding
+          @padding[1] + @padding[3]
+        end
+
+        def vertical_padding
+          @padding[0] + @padding[2]
+        end
+
+        def text_options
+          {inline_format: @inline_format, style: @font_style, size: @size, color: @text_color, font: @font}.compact
+        end
+
+        def natural_width
+          measure.first + horizontal_padding
+        end
+
+        def minimum_width
+          measure.last + horizontal_padding
+        end
+
+        def lines(width)
+          @document.text_lines(@content, text_options, [width - horizontal_padding, 0].max)
+        end
+
+        private
+
+        def measure
+          @measure ||= @document.measure_text(@content, text_options)
+        end
+      end
+
+      # A selection of cells. Assigning an attribute sets it on every cell: `row(0).borders = [:bottom]`
+      class Cells < Array
+        def style(options)
+          options.each { |key, value| public_send(:"#{key}=", value) }
+          self
+        end
+
+        def method_missing(name, *args, &block)
+          if name.to_s.end_with?("=") && Cell.method_defined?(name)
+            each { |cell| cell.public_send(name, *args) }
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          (name.to_s.end_with?("=") && Cell.method_defined?(name)) || super
+        end
+      end
+
+      def initialize(document, data, options = {}, &block)
+        @document = document
+        @width = options[:width]
+        @column_widths = options[:column_widths]
+        @header = options[:header]
+        @position = options.fetch(:position, :left)
+        cell_style = options.fetch(:cell_style, {})
+
+        columns = data.map { |row| Array(row).size }.max || 0
+        @rows = data.map do |row|
+          row = Array(row)
+          Array.new(columns) do |index|
+            value = row[index]
+            Cell.new(document, cell_style.merge(value.is_a?(Hash) ? value : {content: value}))
+          end
+        end
+
+        return unless block
+        (block.arity == 1) ? block.call(self) : instance_exec(&block)
+      end
+
+      def cells
+        Cells.new(@rows.flatten)
+      end
+
+      def row(selector)
+        Cells.new(select(@rows, selector).flatten)
+      end
+      alias_method :rows, :row
+
+      def column(selector)
+        Cells.new(@rows.flat_map { |row| select(row, selector) })
+      end
+      alias_method :columns, :column
+
+      def column_widths
+        @computed_column_widths ||= compute_column_widths
+      end
+
+      def draw
+        widths = column_widths
+        bounds = @document.bounds
+        x = bounds.absolute_left + Geometry.align_offset(@position, bounds.width, widths.sum)
+
+        header_count = case @header
+        when true then 1
+        when Integer then @header
+        else 0
+        end
+        headers = @rows.first(header_count).map { |row| [row, *layout_row(row, widths)] }
+
+        @rows.each_with_index do |row, index|
+          lines, height = layout_row(row, widths)
+
+          if @document.start_new_page_if_needed(height) && index >= header_count
+            headers.each { |header, header_lines, header_height| draw_row(header, header_lines, header_height, widths, x) }
+          end
+
+          draw_row(row, lines, height, widths, x)
+        end
+
+        nil
+      end
+
+      private
+
+      def select(list, selector)
+        selector.is_a?(Integer) ? [list[selector]].compact : Array(list[selector])
+      end
+
+      def layout_row(row, widths)
+        lines = row.each_with_index.map { |cell, index| cell.lines(widths[index]) }
+        height = row.each_with_index.map do |cell, index|
+          TextLayout.height_of(lines[index], cell.leading) + cell.vertical_padding
+        end.max || 0
+        [lines, height]
+      end
+
+      def draw_row(row, lines, height, widths, x)
+        top = @document.y
+
+        row.each_with_index do |cell, index|
+          width = widths[index]
+          bottom = top - height
+
+          @document.fill_rectangle(x, bottom, width, height, color: cell.background_color) if cell.background_color
+
+          @document.draw_text_lines(lines[index], x + cell.padding[3], top - cell.padding[0],
+            width - cell.horizontal_padding, align: cell.align, leading: cell.leading)
+
+          edges = {top: [x, top, x + width, top], bottom: [x, bottom, x + width, bottom], left: [x, top, x, bottom], right: [x + width, top, x + width, bottom]}
+          edges.values_at(*Array(cell.borders)).compact.each do |edge|
+            @document.stroke_line(*edge, color: cell.border_color, width: cell.border_width)
+          end
+
+          x += width
+        end
+
+        @document.y = top - height
+      end
+
+      # Columns start at their natural (unwrapped) width. When the table is too wide,
+      # narrow columns keep their width and wider columns shrink proportionally, never past the table width.
+      # When a table width is given and there's space left over, it's split evenly between columns.
+      def compute_column_widths
+        count = @rows.first&.size || 0
+        natural = Array.new(count) { |i| @rows.map { |row| row[i].natural_width }.max }
+        minimum = Array.new(count) { |i| @rows.map { |row| row[i].minimum_width }.max }
+
+        fixed = case @column_widths
+        when Array then @column_widths.each_with_index.map { |width, i| [i, width] }.reject { |_, width| width.nil? }.to_h
+        when Hash then @column_widths
+        when Numeric then (0...count).map { |i| [i, @column_widths] }.to_h
+        else {}
+        end
+
+        widths = natural.dup
+        fixed.each { |i, width| widths[i] = width }
+        flexible = (0...count).reject { |i| fixed.key?(i) }
+        return widths if flexible.empty?
+
+        target = @width || [widths.sum, @document.bounds.width].min
+        available = target - fixed.values.sum
+        flexible_natural = flexible.sum { |i| natural[i] }
+
+        if flexible_natural > available
+          budget = available
+          columns = flexible.dup
+          loop do
+            share = budget / columns.size.to_f
+            narrow = columns.select { |i| natural[i] <= share }
+            break if narrow.empty?
+            budget -= narrow.sum { |i| natural[i] }
+            columns -= narrow
+            break if columns.empty?
+          end
+
+          # The rest share the budget in proportion to their natural width, but not below their widest
+          # word. If the widest words can't all fit, words are broken rather than overflowing the table.
+          loop do
+            total = columns.sum { |i| natural[i] }
+            break if total.zero?
+            short = columns.select { |i| budget * natural[i] / total < minimum[i] }
+            break if short.empty? || short.sum { |i| minimum[i] } >= budget
+            short.each { |i| widths[i] = minimum[i] }
+            budget -= short.sum { |i| minimum[i] }
+            columns -= short
+          end
+
+          total = columns.sum { |i| natural[i] }
+          columns.each { |i| widths[i] = total.zero? ? 0 : [budget * natural[i] / total, 0].max }
+        elsif @width && flexible_natural < available
+          extra = (available - flexible_natural) / flexible.size.to_f
+          flexible.each { |i| widths[i] += extra }
+        end
+
+        widths
+      end
+    end
+  end
+end

data/lib/receipts/pdf/text_layout.rb

@@ -0,0 +1,175 @@
+module Receipts
+  module PDF
+    # Wraps styled text into lines that fit a given width.
+    #
+    # Input is an Array of [text, Style] chunks. Lines break at spaces, after
+    # hyphens, and at newlines. Words wider than the line are broken anywhere.
+    module TextLayout
+      Style = Struct.new(:font, :size, :color, :link, :underline, :strikethrough, :rise,
+        :character_spacing, :oblique, :fake_bold, keyword_init: true)
+      Run = Struct.new(:text, :style, :width)
+      Line = Struct.new(:runs, :width, :ascender, :descender, :line_gap) do
+        def height
+          ascender + descender
+        end
+      end
+
+      EPSILON = 0.0001
+
+      module_function
+
+      def wrap(chunks, max_width, default_style)
+        lines = []
+
+        paragraphs(chunks, default_style).each do |paragraph_style, paragraph|
+          line = []
+          line_width = 0
+          pending = []
+          pending_width = 0
+
+          items(paragraph).each do |type, pieces|
+            width = measure_pieces(pieces)
+
+            if type == :space
+              next if line.empty?
+              pending.concat(pieces)
+              pending_width += width
+              next
+            end
+
+            if line.any? && line_width + pending_width + width > max_width + EPSILON
+              lines << build_line(line, paragraph_style)
+              line = []
+              line_width = 0
+            else
+              line.concat(pending)
+              line_width += pending_width
+            end
+            pending = []
+            pending_width = 0
+
+            if line.empty? && width > max_width + EPSILON
+              pieces, width = break_word(pieces, max_width, paragraph_style, lines)
+            end
+
+            line.concat(pieces)
+            line_width += width
+          end
+
+          lines << build_line(line, paragraph_style)
+        end
+
+        lines
+      end
+
+      # Width of the text without wrapping
+      def natural_width(chunks, default_style)
+        paragraphs(chunks, default_style).map do |_, paragraph|
+          measure_pieces(paragraph)
+        end.max || 0
+      end
+
+      # Width of the widest word, the narrowest the text can wrap without breaking words
+      def minimum_width(chunks, default_style)
+        paragraphs(chunks, default_style).flat_map do |_, paragraph|
+          items(paragraph).map { |type, pieces| (type == :word) ? measure_pieces(pieces) : 0 }
+        end.max || 0
+      end
+
+      def height_of(lines, leading = 0)
+        return 0 if lines.empty?
+        lines.sum(&:height) + lines[0...-1].sum { |line| line.line_gap + leading }
+      end
+
+      def measure(text, style)
+        style.font.width_of(text, style.size, character_spacing: style.character_spacing)
+      end
+
+      def measure_pieces(pieces)
+        pieces.sum { |text, style| measure(text, style) }
+      end
+
+      # Splits chunks at newlines. Empty paragraphs keep the style of the text around them for their height.
+      def paragraphs(chunks, default_style)
+        paragraphs = [[default_style, []]]
+        chunks.each do |text, style|
+          paragraphs.last[0] = style if paragraphs.last[1].empty?
+          text.split("\n", -1).each_with_index do |part, index|
+            paragraphs << [style, []] if index > 0
+            paragraphs.last[1] << [part, style] unless part.empty?
+          end
+        end
+        paragraphs
+      end
+
+      # Groups text into [:word, pieces] and [:space, pieces] items. A word can span
+      # several chunks with different styles, like "<b>Total</b>:".
+      def items(chunks)
+        items = []
+        word = nil
+
+        chunks.each do |text, style|
+          text.scan(/[ \t]+|[^ \t]+/) do |token|
+            if token.start_with?(" ", "\t")
+              items << [:space, [[token.tr("\t", " "), style]]]
+              word = nil
+            else
+              token.scan(/[^-]*-+|[^-]+/) do |piece|
+                unless word
+                  word = []
+                  items << [:word, word]
+                end
+                word << [piece, style]
+                word = nil if piece.end_with?("-")
+              end
+            end
+          end
+        end
+
+        items
+      end
+
+      # Breaks a word too wide for a line into full lines, returning the remainder
+      def break_word(pieces, max_width, paragraph_style, lines)
+        current = []
+        current_width = 0
+
+        pieces.each do |text, style|
+          text.each_char do |char|
+            width = measure(char, style)
+            if current.any? && current_width + width > max_width + EPSILON
+              lines << build_line(current, paragraph_style)
+              current = []
+              current_width = 0
+            end
+            current << [char, style]
+            current_width += width
+          end
+        end
+
+        [current, current_width]
+      end
+
+      def build_line(pieces, fallback_style)
+        runs = []
+        pieces.each do |text, style|
+          if runs.any? && runs.last.style.equal?(style)
+            runs.last.text += text
+          else
+            runs << Run.new(text.dup, style, 0)
+          end
+        end
+        runs.each { |run| run.width = measure(run.text, run.style) }
+
+        styles = runs.empty? ? [fallback_style] : runs.map(&:style)
+        Line.new(
+          runs,
+          runs.sum(&:width),
+          styles.map { |s| s.font.ascender(s.size) + s.rise }.max,
+          styles.map { |s| s.font.descender(s.size) - s.rise }.max,
+          styles.map { |s| s.font.line_gap(s.size) }.max
+        )
+      end
+    end
+  end
+end