stationery 0.1.0 → 0.2.0

data/lib/stationery/layout/table.rb

@@ -3,25 +3,29 @@
 module Stationery
   module Layout
     # Rows of cells with column widths, per-cell styling through selections,
-    # header rows repeated after a page break, and splitting between rows.
+    # header rows repeated after a page break, and splitting between rows. A
+    # row taller than a fresh page, or any row with split_rows: true, is cut
+    # through its cells and continues below the repeated header.
     class Table < Node
       DEFAULT_CELL = { padding: 5, borders: %i[top right bottom left], border_width: 0.5,
                        border_color: "#000000" }.freeze
 
-      def initialize(rows, context:, widths: nil, width: :auto, header: false, cell: {})
+      def initialize(rows, context:, widths: nil, width: :auto, header: false, split_rows: false, cell: {})
         super()
+        @split_rows = split_rows
         @context = context
         @widths = widths
         @width = width
         @header = header == true ? 1 : (header || 0).to_i
         defaults = DEFAULT_CELL.merge(cell)
-        @cells = rows.map { |row| row.map { |content| content.is_a?(Cell) ? content : Cell.new(content, defaults) } }
+        @cells = rows.map { |row| row.map { |content| build_cell(content, defaults) } }
+        check_header
         yield self if block_given?
       end
 
       def row_count = @cells.size
-      def column_count = @cells.map(&:size).max || 0
-      def cell(row, column) = @cells.dig(row, column)
+      def column_count = grid.column_count
+      def cell(row, column) = grid.at(row, column)
 
       def rows(spec) = Selection.new(self, Selection.indexes(spec, row_count), (0...column_count).to_a)
       alias row rows
@@ -38,6 +42,14 @@ module Stationery
 
       def splittable? = true
 
+      # Forgets measurements taken before a selection restyled cells.
+      def invalidate!
+        @column_widths = nil
+        @column_metrics = nil
+        @row_heights = nil
+        @grid = nil
+      end
+
       def natural_width = column_metric(:natural_width).sum
       def min_width = column_metric(:min_width).sum
 
@@ -61,30 +73,65 @@ module Stationery
 
       def paint(canvas, x, y, width, _height = nil, **)
         widths = column_widths(width)
-        top = y
-        @cells.zip(row_heights(width)).each_with_index do |(row, height), row_index|
-          left = x
-          row.each_with_index do |cell, index|
-            cell.paint(canvas, @context, Rect.new(left, top, widths[index], height),
-                       last_column: index == row.size - 1, last_row: row_index == @cells.size - 1)
-            left += widths[index]
-          end
-          top += height
+        heights = row_heights(width)
+        grid.placements.each do |p|
+          rect = Rect.new(x + widths[0...p.column].sum, y + heights[0...p.row].sum,
+                          widths[p.columns].sum, heights[p.rows].sum)
+          p.cell.paint(canvas, @context, rect, last_column: p.columns.end == column_count,
+                                               last_row: p.rows.end == row_count)
         end
       end
 
-      def split(width, height)
+      def split(width, height, **options)
         heights = row_heights(width)
         used = heights.first(@header).sum
         count = @header
         count += 1 while count < row_count && used + heights[count] <= height + EPSILON && (used += heights[count])
         return [self, nil] if count == row_count
+
+        count = grid.boundaries.grep(@header..count).max
+        split_row(count, width, height - heights.first(count).sum, fresh: options[:fresh]) || split_before(count)
+      end
+
+      private
+
+      def grid = @grid ||= Grid.new(@cells)
+
+      def split_before(count)
         return [nil, self] if count == @header
 
         [with_rows(@cells.first(count)), with_rows(@cells.first(@header) + @cells.drop(count))]
       end
 
-      private
+      def split_row(row, width, space, fresh:)
+        return unless @split_rows || (fresh && row == @header)
+        return unless grid.boundaries.include?(row + 1)
+
+        widths = column_widths(width)
+        placements = grid.placements.select { |p| p.row == row }
+        heads, tails = RowSplitter.new(placements, widths:, context: @context).call(space)
+        return unless heads
+
+        [with_rows(@cells.first(row) + [heads], widths:),
+         with_rows(@cells.first(@header) + [tails] + @cells.drop(row + 1), widths:)]
+      end
+
+      def build_cell(content, defaults)
+        case content
+        when Cell then content
+        when Hash
+          options = content.except(:content, :colspan, :rowspan)
+          Cell.new(content[:content], defaults.merge(options),
+                   colspan: content.fetch(:colspan, 1), rowspan: content.fetch(:rowspan, 1))
+        else Cell.new(content, defaults)
+        end
+      end
+
+      def check_header
+        return if @header.zero? || grid.boundaries.include?([@header, row_count].min)
+
+        raise ArgumentError, "a rowspan crosses the end of the #{@header} header row(s)"
+      end
 
       def target(available)
         case @width
@@ -100,18 +147,17 @@ module Stationery
       end
 
       def column_metric(metric)
-        Array.new(column_count) do |c|
-          @cells.filter_map { |row| row[c]&.public_send(metric, @context) }.max || 0
-        end
+        @column_metrics ||= {}
+        @column_metrics[metric] ||= grid.column_metric { |p| p.cell.public_send(metric, @context) }
       end
 
       def row_heights(width)
-        widths = column_widths(width)
-        @cells.map { |row| row.each_with_index.map { |cell, i| cell.measure(@context, widths[i]) }.max || 0 }
+        @row_heights ||= {}
+        @row_heights[width] ||= grid.row_heights(column_widths(width)) { |p, span| p.cell.measure(@context, span) }
       end
 
-      def with_rows(rows)
-        self.class.new(rows, context: @context, widths: @widths, width: @width, header: @header)
+      def with_rows(rows, widths: @widths)
+        self.class.new(rows, context: @context, widths:, width: @width, header: @header, split_rows: @split_rows)
       end
     end
   end

data/lib/stationery/layout/table_of_contents/entry.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    class TableOfContents
+      # One contents row. The title wraps within the room the number slot
+      # leaves; the leader and the number sit on its last line, and the whole
+      # row links to the entry's anchor once that anchor has painted.
+      class Entry < Node
+        LEADERS = { dots: { dash: [0, 3], cap: :round, width: 1 }, line: { width: 0.5 } }.freeze
+
+        def initialize(entry, context:, options:, slot:)
+          super()
+          @entry = entry
+          @context = context
+          @options = options
+          @slot = slot
+          @paragraphs = {}
+        end
+
+        def measure(width) = paragraph(width).height
+        def natural_width = paragraph(Float::INFINITY).lines.map(&:width).max.to_f + offset + @slot + @options.gap
+
+        def paint(canvas, x, y, width, _height = nil, **)
+          text = paragraph(width)
+          text.draw(canvas, x + offset, y)
+          last = text.lines.last
+          baseline = y + text.height - last.height + last.ascent
+          slot_x = x + width - @slot
+          draw_leader(canvas, x + offset + last.width + 2, slot_x, baseline)
+          canvas.number_slot(@entry.anchor, x: slot_x, baseline:, width: @slot, style: @context.style,
+                                            link: [x + offset, y, width - offset, text.height])
+        end
+
+        private
+
+        def offset = @options.indent * (@entry.level - 1)
+
+        def draw_leader(canvas, from, to, baseline)
+          leader = LEADERS[@options.leader]
+          return unless leader && to > from
+
+          canvas.line(from, baseline, to, baseline, color: @context.style.color, **leader)
+        end
+
+        def paragraph(width)
+          @paragraphs[width] ||= ::Stationery::Text::Paragraph.new(
+            [::Stationery::Text::Run.new(@entry.title, @context.style)],
+            book: @context.book, width: [width - offset - @slot - @options.gap, 1].max,
+            fallback_style: @context.style
+          )
+        end
+      end
+    end
+  end
+end

data/lib/stationery/layout/table_of_contents.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    # One row per outline entry: the title (indented by level), a leader and a
+    # right-aligned page number filled in once pages are known. Rows are built
+    # on first use, so bookmarks declared after the contents still appear.
+    class TableOfContents < Node
+      Options = Data.define(:levels, :leader, :indent, :number_width, :gap)
+
+      def initialize(outline, context:, levels: 1.., leader: :dots, indent: 12, number_width: nil, gap: 4)
+        super()
+        @outline = outline
+        @context = context
+        @options = Options.new(levels, leader, indent, number_width, gap)
+      end
+
+      def splittable? = true
+      def measure(width) = rows.measure(width)
+      def natural_width = rows.natural_width
+      def min_width = rows.min_width
+      def split(width, height, **) = rows.split(width, height, **)
+      def paint(canvas, x, y, width, height = nil, **) = rows.paint(canvas, x, y, width, height)
+
+      private
+
+      def rows
+        @rows ||= Flow.new(entries.map { |entry| Entry.new(entry, context: @context, options: @options, slot:) },
+                           gap: @options.gap)
+      end
+
+      def entries
+        levels = @options.levels
+        @outline.entries.select { |entry| levels.is_a?(Integer) ? entry.level <= levels : levels.include?(entry.level) }
+      end
+
+      def slot
+        style = @context.style
+        @options.number_width || @context.book.resolve(style).first.width_of("0000", style.render_size)
+      end
+    end
+  end
+end

data/lib/stationery/layout/text.rb

@@ -8,7 +8,7 @@ module Stationery
 
       def initialize(runs, context:, align: :left, leading: 0, paragraph: nil)
         super()
-        @runs = runs
+        @runs = context.book.fallback(runs)
         @context = context
         @align = align
         @leading = leading
@@ -24,7 +24,7 @@ module Stationery
         paragraph(width).draw(canvas, x, y)
       end
 
-      def split(width, height)
+      def split(width, height, **)
         head, tail = paragraph(width).split(height)
         [head && from(head), tail && from(tail)]
       end
@@ -39,9 +39,10 @@ module Stationery
 
       def min_width
         @min_width ||= @runs.flat_map do |run|
-          font = @context.book.resolve(run.style).first
+          style = run.style
+          font = @context.book.resolve(style).first
           run.text.split(/[ \t\n]+/).map do |word|
-            font.width_of(word, run.style.render_size, letter_spacing: run.style.letter_spacing)
+            font.width_of(word, style.render_size, letter_spacing: style.letter_spacing, kerning: style.kerning)
           end
         end.max || 0
       end

data/lib/stationery/layout/wrap.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Layout
+    # Children laid out left to right at their own widths, wrapping onto new
+    # rows when the width runs out — chips, tags, badges. Splits between rows.
+    class Wrap < Node
+      attr_reader :children
+
+      def initialize(children, gap: 0, row_gap: 0, align: :left)
+        super()
+        @children = children
+        @gap = gap
+        @row_gap = row_gap
+        @align = align
+      end
+
+      def splittable? = true
+
+      def natural_width
+        widths = @children.map { |child| child.fixed_width(Float::INFINITY) || child.natural_width }
+        widths.sum + (@gap * [widths.size - 1, 0].max)
+      end
+
+      def min_width = @children.map { |child| child.fixed_width(Float::INFINITY) || child.min_width }.max || 0
+
+      # [[[child, width], …], …] — one array per row.
+      def rows(width)
+        @children.each_with_object([[]]) do |child, rows|
+          own = [child.fixed_width(width) || width, width].min
+          used = rows.last.sum { |_, w| w } + (@gap * rows.last.size)
+          rows << [] if rows.last.any? && used + own > width + EPSILON
+          rows.last << [child, own]
+        end.reject(&:empty?)
+      end
+
+      def measure(width)
+        memoize_by_width(width) do
+          heights = row_heights(width)
+          heights.sum + (@row_gap * [heights.size - 1, 0].max)
+        end
+      end
+
+      def paint(canvas, x, y, width, _height = nil, **)
+        top = y
+        rows(width).zip(row_heights(width)).each do |row, height|
+          used = row.sum { |_, w| w } + (@gap * (row.size - 1))
+          left = x + Geometry.align_offset(@align, width, used)
+          row.each do |child, w|
+            child.paint(canvas, left, top, w)
+            canvas.debug_rect(left, top, w, child.measure(w), :flow) if canvas.debug?
+            left += w + @gap
+          end
+          top += height + @row_gap
+        end
+      end
+
+      def split(width, height, **)
+        heights = row_heights(width)
+        used = 0
+        count = heights.take_while.with_index { |h, i| (used += h + (i.zero? ? 0 : @row_gap)) <= height + EPSILON }.size
+        return [self, nil] if count == heights.size
+        return [nil, self] if count.zero?
+
+        taken = rows(width).first(count).sum(&:size)
+        [with(@children.first(taken)), with(@children.drop(taken))]
+      end
+
+      private
+
+      def row_heights(width)
+        rows(width).map { |row| row.map { |child, w| child.measure(w) }.max }
+      end
+
+      def with(children) = self.class.new(children, gap: @gap, row_gap: @row_gap, align: @align)
+    end
+  end
+end

data/lib/stationery/list_markers.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Ordered-list labels: decimal, alpha, roman (lower or upper case) or a
+  # Proc given the number. Formats with no numeral for a number fall back to
+  # decimal.
+  module ListMarkers
+    ROMAN = { 1000 => "m", 900 => "cm", 500 => "d", 400 => "cd", 100 => "c", 90 => "xc",
+              50 => "l", 40 => "xl", 10 => "x", 9 => "ix", 5 => "v", 4 => "iv", 1 => "i" }.freeze
+
+    module_function
+
+    def label(format, number, suffix = ".") = "#{numeral(format, number)}#{suffix}"
+
+    def numeral(format, number)
+      case format
+      when Proc then format.call(number).to_s
+      when :decimal then number.to_s
+      when :alpha then alpha(number)
+      when :upper_alpha then alpha(number).upcase
+      when :roman then roman(number)
+      when :upper_roman then roman(number).upcase
+      else raise ArgumentError, "unknown list format: #{format.inspect}"
+      end
+    end
+
+    def alpha(number)
+      return number.to_s if number < 1
+
+      letters = +""
+      while number.positive?
+        number, rest = (number - 1).divmod(26)
+        letters.prepend((97 + rest).chr)
+      end
+      letters
+    end
+
+    def roman(number)
+      return number.to_s unless (1..3999).cover?(number)
+
+      ROMAN.each_with_object(+"") do |(value, letters), numeral|
+        count, number = number.divmod(value)
+        numeral << (letters * count)
+      end
+    end
+  end
+end

data/lib/stationery/markdown/block_parser/containers.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Markdown
+    class BlockParser
+      # Blockquotes and lists: each collects its lines (stripping the `>` or the item's content indent,
+      # taking lazy continuation lines) and parses them as a nested document. Tight and loose items both
+      # hold Paragraphs; the model does not distinguish them.
+      module Containers
+        QUOTE = /\A {0,3}> ?/
+        LIST = /\A(?<indent> {0,3})(?<marker>[-+*]|(?<number>\d{1,9})[.)])(?<space> *)(?<rest>.*)\z/
+
+        private
+
+        def blockquote
+          lines = []
+          while (line = @lines[@index])
+            if QUOTE.match?(line) then lines << line.sub(QUOTE, "")
+            elsif !blank?(line) && !blank?(lines.last) && !interrupts?(line) then lines << line
+            else break
+            end
+            @index += 1
+          end
+          Rich::Blockquote.new(blocks: nested(lines))
+        end
+
+        def list(first)
+          kind = first[:marker][-1]
+          items = []
+          while (match = next_item(kind))
+            items << nested(item_lines(match))
+          end
+          ordered = !first[:number].nil?
+          Rich::List.new(ordered:, start: (first[:number].to_i if ordered), items:)
+        end
+
+        # The marker of the list's next item, after any blank lines between items.
+        def next_item(kind)
+          index = @index
+          index += 1 while @lines[index] && blank?(@lines[index])
+          line = @lines[index].to_s
+          match = list_marker(line)
+          return unless match && match[:marker][-1] == kind && !THEMATIC.match?(line)
+
+          @index = index
+          match
+        end
+
+        def item_lines(match)
+          column, first = content_start(match)
+          lines = [first]
+          while (line = @lines[@index += 1])
+            if blank?(line) then break if lines == [""]
+
+                                 lines << ""
+            elsif indent(line) >= column then lines << line[column..]
+            elsif !lines.last.empty? && !list_marker(line) && !interrupts?(line) then lines << line.lstrip
+            else break
+            end
+          end
+          give_back_blanks(lines)
+        end
+
+        def content_start(match)
+          width = match[:indent].length + match[:marker].length
+          spaces = match[:space].length
+          return [width + 1, ""] if match[:rest].empty?
+          return [width + 1, (" " * (spaces - 1)) + match[:rest]] if spaces > 4
+
+          [width + spaces, match[:rest]]
+        end
+
+        def give_back_blanks(lines)
+          while lines.length > 1 && lines.last.empty?
+            lines.pop
+            @index -= 1
+          end
+          lines
+        end
+
+        def list_marker(line)
+          match = LIST.match(line)
+          match if match && (!match[:space].empty? || match[:rest].empty?)
+        end
+
+        # Only a non-empty item interrupts a paragraph, and an ordered one only when it starts at 1.
+        def list_interrupts?(line)
+          match = list_marker(line)
+          match && !match[:rest].strip.empty? && (match[:number].nil? || match[:number].to_i == 1)
+        end
+      end
+    end
+  end
+end

data/lib/stationery/markdown/block_parser/tables.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Markdown
+    class BlockParser
+      # GFM tables: a header row, a delimiter row of the same width setting each column's alignment, and
+      # body rows up to a blank line or another block. Body rows are padded or cut to the header's width.
+      module Tables
+        DELIMITER = /\A {0,3}\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*\z/
+        ALIGNMENTS = { "::" => :center, ":" => :left, "-:" => :right }.freeze
+
+        private
+
+        def table_start?
+          header = @lines[@index]
+          delimiter = @lines[@index + 1]
+          header.include?("|") && delimiter && DELIMITER.match?(delimiter) &&
+            cells(header).length == cells(delimiter).length
+        end
+
+        def table
+          header = cells(@lines[@index])
+          aligns = cells(@lines[@index + 1]).map { |cell| alignment(cell) }
+          rows = [row(header, aligns, header: true)]
+          @index += 2
+          while (line = @lines[@index]) && !blank?(line) && !interrupts?(line)
+            texts = cells(line)
+            rows << row(Array.new(header.length) { |i| texts[i] || "" }, aligns)
+            @index += 1
+          end
+          Rich::Table.new(rows:)
+        end
+
+        def row(texts, aligns, header: false)
+          texts.zip(aligns).map do |text, align|
+            Rich::Cell.new(header:, align:, blocks: text.empty? ? [] : [Rich::Paragraph.new(inlines: text)])
+          end
+        end
+
+        def alignment(cell)
+          key = (cell.start_with?(":") ? ":" : "") + (cell.end_with?(":") ? ":" : "")
+          key = "-:" if key == ":" && !cell.start_with?(":")
+          ALIGNMENTS[key]
+        end
+
+        def cells(line)
+          text = line.strip.delete_prefix("|")
+          text = text.delete_suffix("|") unless text.end_with?("\\|")
+          text.split(/(?<!\\)\|/, -1).map { |cell| cell.strip.gsub("\\|", "|") }
+        end
+      end
+    end
+  end
+end