raindown 0.17.2 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce48803b10f9d818849d224607930c3f41c63d66a830e9da2fa6ef43c877a5cb
-  data.tar.gz: 040a45c39fc4d1439d80af01c7c6d9d937d24850f69093c9e478c79964305bb6
+  metadata.gz: baf58826a9f492870795c2cfb36104ffb214b7494c0b14a2b11aa5f5a7711c64
+  data.tar.gz: 136d56da8dd7574698769f971bcce51662c89f29b28e2b87acb758017f9ee708
 SHA512:
-  metadata.gz: 1e1109ca3ea21b6ae214b5d3bff967d2936e53b23ea0c71b1ca97bbcc208ac4249f5b14d151fb9a94f575d56fbdbfde12ccba1c12bf1b4a287ab632508df1260
-  data.tar.gz: 22ba4b827f93a2c9edaf6d21c7be2e8d6916b5a95627e2f29b1309eec01eb6de59cb126ab9874a725ca3b089813529ec7b902501541c06661e5d87922ca9ee41
+  metadata.gz: 2ceb319ab5a5c1482a6d09f98b75e95bf22ece5ca8477b54621ee542691c6de3ee243dc0ef3f580971167cb116990a89a28ae5a4012b50c16ec659a8fcdf5cfa
+  data.tar.gz: 411f712343878e32a1efc7d99932254984e3f0dc45ba91a8b41316fcbf61e9aa0c404ea7d66fc75e0293975d60632e28bde04adcd044d8e3dc36c02ddf9390c2

data/lib/raindown/node_injector.rb

@@ -4,6 +4,7 @@ require_relative '../raindown'
 require_relative 'bare_directives'
 require_relative 'front_matter'
 require_relative 'node_blocks'
+require_relative 'written'
 
 module Raindown
   # Writes each node block's Markdown below its directive, replacing what it wrote before, when it's in comments or
@@ -11,6 +12,10 @@ module Raindown
   class NodeInjector
     class BlankLine < StandardError; end
 
+    # A comment on its own line that isn't a directive, like <!-- 2 rows · 3f2a9c -->, which straight below a directive
+    # is its node's comment, passed to its rewrite as comment:.
+    COMMENT = /\A\s*<!--(?!\s*(?::[A-Za-z]|[A-Za-z][\w-]*(?:::[A-Z]\w*)*:))\s*(.*?)\s*-->\s*\z/
+
     # Rewriter interface. Content without a node block is returned unchanged.
     def self.rewrite(content:, path: nil, bare: false, metadata: NoMetadata, **)
       new(content:, path:, bare:, metadata:).call
@@ -42,22 +47,25 @@ module Raindown
     private
 
     def block_lines(lines, block)
-      context = { document: @content, metadata: @metadata, bare: @bare, written: written_lines(lines, block) }
-      markdown = node_markdown(block, context)
-      written = markdown.empty? ? [] : "#{markdown}\n".lines
+      comment, written = comment_and_written(written_lines(lines, block))
+      context = { document: @content, metadata: @metadata, bare: @bare, comment:, written: }
+      written = written_lines_of(node_written(block, context))
       return [line(lines[block[:open]]), *bare(written, block)] unless block[:close]
 
       delimited(lines, block, written)
     end
 
     # A node that raises writes why in its place, like a Problem, so the rest of the file still writes back.
-    def node_markdown(block, context)
+    def node_written(block, context)
       @problems << block[:node].warning if block[:node].is_a?(Problem)
-      Nodes.call(block[:node], :rewrite, **context).to_s.chomp
+      written = Nodes.call(block[:node], :rewrite, **context)
+      return written if written.is_a?(Written)
+
+      Written.new(written.to_s)
     rescue StandardError => e
       problem = Problem.new("Couldn't write: #{e.message}", block[:open] + 1)
       @problems << problem.warning
-      problem.rewrite
+      Written.new(problem.rewrite)
     end
 
     # The directive, what the node wrote and the end tag, straight after each other, as a comment on its own line ends
@@ -72,6 +80,22 @@ module Raindown
       raise BlankLine, "#{name} writes blank lines, so it needs <!-- #{name}: --> and <!-- :#{name} --> around it"
     end
 
+    # Its lines: its comment, straight below its directive, then its Markdown.
+    def written_lines_of(written)
+      markdown = written.to_s.chomp
+      lines = markdown.empty? ? [] : "#{markdown}\n".lines
+      return lines unless written.comment
+
+      ["<!-- #{written.comment} -->\n", *lines]
+    end
+
+    # The comment the block's node wrote straight below its directive, if it wrote one, and the lines it wrote below that.
+    def comment_and_written(lines)
+      return [nil, lines] unless lines.first&.match?(COMMENT)
+
+      [lines.first[COMMENT, 1], lines.drop(1)]
+    end
+
     # What the block's node wrote last time, between its directive and its end tag, or the next blank line.
     def written_lines(lines, block)
       lines[(block[:open] + 1)...(block[:close] || (block[:last] + 1))]

data/lib/raindown/table/file_cell.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'table_formulas'
+
+module Raindown
+  # A cell of a table: block's file, as its table shows it: its value, worked out from its formula, and clipped to fit
+  # its column, ending in an ellipsis, when the column's fixed. Deleting the padding around a formula's value shows its
+  # formula, and deleting a clipped cell's ellipsis shows its full text, wrapped onto |+ rows, each until it's changed,
+  # or, for its full text, an ellipsis is typed into it again, which clips it.
+  FileCell = Data.define(:saved, :value, :column) do
+    # As the table shows it, unless it's revealed.
+    def shown
+      return value unless column
+
+      column.clip(value)
+    end
+
+    # Whether the written cell still shows it: its value, as shown or in full, or clipped at another width, as it was
+    # before its column's width changed, or in full with an ellipsis typed into it, its formula, ignoring whitespace, or
+    # its clipped start, with the ellipsis deleted.
+    def unchanged_by?(cell)
+      [shown, value, revealing].include?(cell) || formula_in?(cell) || clip_of_value?(cell) || collapsing?(cell)
+    end
+
+    # Whether the written cell shows its formula, or its full text, in place of what the table shows. A full text written
+    # on one line, before its column was fixed, isn't, so it's clipped.
+    def revealed_by?(cell, squeezed:, wrapped:)
+      return formula_in?(cell) || (cell == value && squeezed) if formula?
+
+      clipped? && (cell == revealing || (cell == value && wrapped))
+    end
+
+    # The value the written cell gives it: its own while it's unchanged, or else what was typed, with the end that was
+    # clipped off back in place of the ellipsis, while it has one, like when its start's edited, or more typed after it.
+    def value_from(cell)
+      return value if unchanged_by?(cell)
+      return cell unless cell.include?('…')
+
+      before, _, after = cell.partition('…')
+      hidden = clipped_off(before)
+      return cell unless hidden
+
+      "#{before}#{hidden}#{after}"
+    end
+
+    private
+
+    def formula?
+      TableFormulas.formula?(saved)
+    end
+
+    def formula_in?(cell)
+      formula? && cell.gsub(/\s+/, '') == saved.gsub(/\s+/, '')
+    end
+
+    # Its full text with an ellipsis typed into it, like … or ..., anywhere between its words, to clip it again.
+    def collapsing?(cell)
+      ellipsis = /\s*(?:…|\.\.\.)\s*/
+      cell.match?(ellipsis) && cell.sub(ellipsis, ' ').strip == value
+    end
+
+    def clip_of_value?(cell)
+      cell.end_with?('…') && value.length >= cell.length && value.start_with?(cell.delete_suffix('…'))
+    end
+
+    # The end clipped off after the start before the ellipsis: the rest of its value when that's how it starts, or else,
+    # when its start's been edited, what's after the start it's clipped to now.
+    def clipped_off(before)
+      return value.delete_prefix(before) if value.start_with?(before)
+
+      value.delete_prefix(revealing) if clipped?
+    end
+
+    def clipped?
+      shown != value
+    end
+
+    # Its clipped start, without the ellipsis, which shows its full text when that's deleted.
+    def revealing
+      shown.delete_suffix('…') if clipped?
+    end
+  end
+end

data/lib/raindown/table/markdown_table.rb

@@ -2,19 +2,36 @@
 
 module Raindown
   # Rows of cells as a Markdown table, its first row the header, and back again. A | in a cell is escaped as \|, and
-  # a line break is written as a space, as a table's cells are one line. The TableFormatter lines up its columns.
+  # a line break is written as a space, as a table's cells are one line. A row starting with |+, carrying on the row
+  # above, is read as part of it. The TableFormatter lines up its columns.
   module MarkdownTable
-    SEPARATOR = /\A\|?(\s*:?-+:?\s*\|)*\s*:?-+:?\s*\|?\z/
+    SEPARATOR = /\A\|?(\s*:?[-=]+:?\s*\|)*\s*:?[-=]+:?\s*\|?\z/
     # A | that isn't escaped.
     PIPE = /(?<!\\)\|/
 
     module_function
 
-    def format(rows)
+    # With the delimiter's cells, like ':===', when it has one for each column, keeping their alignment and widths. A
+    # cell can be lines, wrapped onto |+ rows below its row.
+    def format(rows, delimiter = nil)
       return '' if rows.empty?
 
-      header, *body = rows.map { |row| "| #{row.map { escape(it) }.join(' | ')} |" }
-      [header, "|#{Array.new(rows.first.length, '---').join('|')}|", *body].join("\n")
+      delimiter = Array.new(rows.first.length, '---') unless delimiter&.length == rows.first.length
+      header, *body = rows.flat_map { row_lines(it) }
+      [header, "|#{delimiter.join('|')}|", *body].join("\n")
+    end
+
+    def row_lines(row)
+      lines = row.map { Array(it) }
+      starts = ['| ', *Array.new(lines.map(&:length).max - 1, '|+')]
+      starts.each_with_index.map { |start, line| "#{start}#{lines.map { escape(it[line].to_s) }.join(' | ')} |" }
+    end
+
+    # The cells of the table's delimiter row, like ['---', ':==='], or nil when the lines aren't a table.
+    def delimiter(lines)
+      return unless lines[1]&.strip&.match?(SEPARATOR)
+
+      lines[1].strip.delete_prefix('|').delete_suffix('|').split('|').map(&:strip)
     end
 
     # The rows of the table in the lines, leaving out its separator, or none when they aren't a table.
@@ -22,16 +39,40 @@ module Raindown
       padded_rows(lines).map { |row| row.map { cell(it) } }
     end
 
-    # The rows of the table in the lines, their cells as written, padding and all, leaving out its separator.
+    # The rows of the table in the lines, their cells as written, padding and all, leaving out its separator, with each
+    # |+ row's cells joined into the row above's, on lines of their own.
     def padded_rows(lines)
-      return [] unless lines[1]&.strip&.match?(SEPARATOR)
+      return [] unless delimiter(lines)
+
+      table_lines = [lines[0], *lines.drop(2)].map(&:strip).take_while { it.start_with?('|') }
+      table_lines.each_with_object([]) do |line, rows|
+        cells = padded_cells(line)
+        next rows << cells unless line.start_with?('|+') && rows.any?
+
+        rows[-1] = rows.last.zip(cells).map { |above, more| joined_cell(above, more.to_s) }
+      end
+    end
+
+    # The line's cells, padding and all, without its outer pipes, or the |+ starting it.
+    def padded_cells(line)
+      line.delete_prefix(lead(line)).delete_suffix('|').split(PIPE, -1)
+    end
+
+    def lead(line)
+      return '|+' if line.start_with?('|+')
+
+      '|'
+    end
+
+    # The cell carried on by the one below it, or as it was, padding and all, when that's blank.
+    def joined_cell(above, more)
+      return above if more.strip.empty?
 
-      table_lines = [lines[0], *lines.drop(2)].take_while { it.strip.start_with?('|') }
-      table_lines.map { it.strip.delete_prefix('|').delete_suffix('|').split(PIPE, -1) }
+      [above.strip, more.strip].reject(&:empty?).join("\n")
     end
 
     def cell(padded)
-      padded.strip.gsub('\|', '|')
+      one_line(padded.strip).gsub('\|', '|')
     end
 
     def escape(cell)

data/lib/raindown/table/matched_rows.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Raindown
+  # Which of a file's rows each of a table's rows shows, by index, given whether a table row shows a file row, so a row
+  # added or removed doesn't move the rows after it onto others. Rows that are the same in both are matched, in order,
+  # then those left between them are paired in order, like a row that's been edited.
+  class MatchedRows
+    def initialize(rows, file_rows, &same)
+      @rows = rows
+      @file_rows = file_rows
+      @same = same
+    end
+
+    # Each table row's file row, or nil for a row that's new.
+    def file_rows
+      [].tap do |matched|
+        [[-1, -1], *common_rows, [@rows, @file_rows]].each_cons(2) do |(row, file_row), (next_row, next_file_row)|
+          matched[row] = file_row unless row.negative?
+          (row + 1...next_row).zip(file_row + 1...next_file_row) { |gap_row, gap_file_row| matched[gap_row] = gap_file_row }
+        end
+      end
+    end
+
+    private
+
+    # The longest run of rows, in order, the same in both, as pairs of their indexes. Rows the same at the start and
+    # end are matched first, so only the few between them, being edited, are compared each with each.
+    def common_rows
+      head = matching_run((0...@rows).zip(0...@file_rows))
+      rows, file_rows = [@rows, @file_rows].map { (head.length...it).to_a }
+      tail = matching_run(rows.reverse.zip(file_rows.reverse)).reverse
+      rows, file_rows = [rows, file_rows].map { it.take(it.length - tail.length) }
+      [*head, *common_pairs(rows, file_rows, common_lengths(rows, file_rows)), *tail]
+    end
+
+    def matching_run(pairs)
+      pairs.take_while { |row, file_row| file_row && @same.call(row, file_row) }
+    end
+
+    # How many rows, at most, the rows and file rows from each on have in common.
+    def common_lengths(rows, file_rows)
+      rows.reverse.each_with_object([Array.new(file_rows.length + 1, 0)]) do |row, lengths|
+        lengths.unshift(common_lengths_from(row, file_rows, lengths.first))
+      end
+    end
+
+    # The common lengths from the row, from those from the row below it.
+    def common_lengths_from(row, file_rows, below)
+      file_rows.each_index.reverse_each.with_object(Array.new(file_rows.length + 1, 0)) do |j, lengths|
+        lengths[j] = @same.call(row, file_rows[j]) ? below[j + 1] + 1 : [below[j], lengths[j + 1]].max
+      end
+    end
+
+    def common_pairs(rows, file_rows, lengths)
+      i = j = 0
+      pairs = []
+      while i < rows.length && j < file_rows.length
+        if @same.call(rows[i], file_rows[j])
+          pairs << [rows[i], file_rows[j]]
+          i += 1
+          j += 1
+        elsif lengths[i + 1][j] >= lengths[i][j + 1]
+          i += 1
+        else
+          j += 1
+        end
+      end
+      pairs
+    end
+  end
+end

data/lib/raindown/table/table.rb

@@ -5,7 +5,9 @@ require 'json'
 
 require_relative '../node'
 require_relative '../utils'
+require_relative '../written'
 require_relative 'markdown_table'
+require_relative 'table_column'
 require_relative 'table_file'
 require_relative 'table_formulas'
 require_relative 'written_table'
@@ -14,7 +16,7 @@ module Raindown
   # The node behind table:, a CSV or TSV file relative to the project as a Markdown table, after a comment of how many
   # rows it has and a hash of them, as they were when the table and the file last matched:
   #   table: 'data/team.csv'
-  #   <!-- table 2 rows · 3f2a9c -->
+  #   <!-- 2 rows · 3f2a9c -->
   #   | name | role     |
   #   |------|----------|
   #   | Ada  | engineer |
@@ -25,7 +27,8 @@ module Raindown
   # cells in the file, like =SUM(B), show their values, and keep their formulas while their values are left alone. Delete
   # the padding around one's value and it shows its formula, to edit, until it's changed.
   class Table < Node
-    COMMENT = /\A<!-- table (?:conflict|\d+ rows?) · (\h+) -->\z/
+    # The hash in its comment, like 3f2a9c in "2 rows · 3f2a9c".
+    HASH = /· (\h+)\z/
     BOLD = /\A\*\*.*\*\*\z/
     # The table a new file starts with, when there's no table to make it from.
     STARTER = [['Column 1', 'Column 2'], ['', '']].freeze
@@ -37,11 +40,11 @@ module Raindown
 
     # Written is what it wrote last time, so it can tell which of the table and the file changed since. A file that's
     # not there yet is made, from the table below it, or else one to fill in.
-    def rewrite(written: [], metadata: NoMetadata)
+    def rewrite(written: [], metadata: NoMetadata, comment: nil)
       path = data_path(metadata)
       lines = written.map(&:chomp)
       create_file(path, lines) if missing_file?(path, metadata)
-      data_error(path, metadata)&.then { Problem.alert(it) } || synced(path, lines)
+      data_error(path, metadata)&.then { Problem.alert(it) } || synced(path, lines, comment)
     end
 
     # Write-in, in <{ }>, the table only shows its file, and never writes to it.
@@ -69,10 +72,9 @@ module Raindown
       TableFile.supported?(path) && Utils.inside?(path, data_root(metadata)) && !File.exist?(path)
     end
 
-    # From the table as it's written, which has no comment yet when it's just been typed, below any alert saying why
-    # there was no file.
+    # From the table as it's written, below any alert saying why there was no file.
     def create_file(path, lines)
-      rows = MarkdownTable.parse(lines.grep_v(COMMENT).grep_v(/\A>/))
+      rows = MarkdownTable.parse(lines.grep_v(/\A>/))
       rows = STARTER if rows.empty?
       TableFile.create(path, rows)
     end
@@ -86,16 +88,16 @@ module Raindown
       "Can't show #{@data.inspect} as a table: no such file" unless File.file?(path)
     end
 
-    def synced(path, written)
+    def synced(path, written, comment)
       file = TableFile.read(path)
       shown = TableFormulas.evaluate(file)
-      synced_hash = written.first&.[](COMMENT, 1)
-      table = WrittenTable.new(written_rows(written), file)
-      return markdown(file, table.revealed) if unchanged?(table.rows, synced_hash, shown)
-      return markdown(TableFile.write(path, with_file_cells(table.rows, file, shown)), table.revealed) if hash_rows(shown) == synced_hash
+      synced_hash = comment&.[](HASH, 1)
+      table = WrittenTable.new(written_rows(written), file, MarkdownTable.delimiter(written))
+      return markdown(file, table) if unchanged?(table.rows, synced_hash, shown)
+      return markdown(TableFile.write(path, table.saved_rows), table) if hash_rows(shown) == synced_hash
 
       warn "raindown: #{@data} and its table both changed, so neither is written until they match"
-      ["<!-- table conflict · #{synced_hash} -->", *written.drop(1)].join("\n")
+      Written.new(written.join("\n"), comment: "conflict · #{synced_hash}")
     end
 
     # Whether there's nothing to write back: the table's rows are as it wrote them, or as the file's are, or it's new.
@@ -105,37 +107,27 @@ module Raindown
 
     # The table's rows as it was written, padding and all, leaving out its total.
     def written_rows(written)
-      header, *body = MarkdownTable.padded_rows(written.drop(1))
+      header, *body = MarkdownTable.padded_rows(written)
       [header, *body.reject { total_row?(it.map(&:strip)) }].compact
     end
 
-    def markdown(rows, revealed = [])
+    # Written with the delimiter it was written with, its cells fit to its fixed columns.
+    def markdown(rows, written)
       return '' if rows.empty?
 
       shown = TableFormulas.evaluate(rows)
       count = rows.length - 1
-      table = MarkdownTable.format(with_total(with_revealed(shown, rows, revealed)))
-      "<!-- table #{count} row#{'s' unless count == 1} · #{hash_rows(shown)} -->\n#{table}"
+      cells = with_total(with_revealed(shown, rows, written.revealed))
+      columns = TableColumn.all(written.delimiter, rows)
+      table = MarkdownTable.format(TableColumn.fit(cells, columns, written.revealed), written.delimiter)
+      Written.new(table, comment: "#{count} row#{'s' unless count == 1} · #{hash_rows(shown)}")
     end
 
-    # The values, but for each revealed cell, which shows its formula.
+    # The values, but for each revealed cell, which shows its formula, or its full text.
     def with_revealed(values, rows, revealed)
       revealed.each_with_object(values.map(&:dup)) { |(row, column), shown| shown[row][column] = rows[row][column] }
     end
 
-    # The table's rows, keeping the file's cell where the table still shows it, like a formula as its value, or a cell
-    # with line breaks on one line.
-    def with_file_cells(table, file, shown)
-      table.each_with_index.map do |row, row_index|
-        row.each_with_index.map do |cell, column|
-          kept = file.dig(row_index, column)
-          next kept if kept && MarkdownTable.one_line(shown.dig(row_index, column).to_s) == cell
-
-          cell
-        end
-      end
-    end
-
     def with_total(rows)
       return rows unless @total && rows.length > 1
 

data/lib/raindown/table/table_column.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+module Raindown
+  # A table's column: its alignment, from its delimiter cell's colons, and its width, that of its widest cell, or as wide
+  # as its delimiter when that's equals signs, like |====|, which is fixed. An equals sign typed into dashes, like
+  # |-=---|, makes it fixed as wide as it was, and a dash typed into equals signs, like |==-==|, makes it widen again.
+  TableColumn = Data.define(:delimiter, :width) do
+    # The columns of the delimiter's cells, while it has one for each of the rows' columns.
+    def self.all(delimiter, rows)
+      return [] unless delimiter&.length == rows.first&.length
+
+      delimiter.each_with_index.map { |cell, i| from(cell, rows.map { it[i].to_s }) }
+    end
+
+    # The rows with each cell clipped to fit its fixed column, but for those revealed, which are wrapped to fit it as
+    # lines instead, but for the header's, as + rows can only be below the delimiter.
+    def self.fit(rows, columns, revealed)
+      rows.each_with_index.map do |row, row_index|
+        row.each_with_index.map do |cell, column|
+          next cell unless columns[column]&.fixed?
+          next columns[column].clip(cell) unless revealed.include?([row_index, column])
+          next cell if row_index.zero?
+
+          columns[column].wrap(cell)
+        end
+      end
+    end
+
+    def self.from(delimiter, cells)
+      return new(delimiter:, width: delimiter.length - fixing(delimiter)) if fixed?(delimiter)
+
+      new(delimiter:, width: [*cells.map { display_width(it) }, 3].max)
+    end
+
+    # Wide characters like CJK and emoji take two columns. Emoji are always measured as two,
+    # instead of guessing from the terminal, so a file formats the same on every machine.
+    def self.display_width(cell)
+      Unicode::DisplayWidth.of(cell, emoji: :all)
+    end
+
+    # Equals signs, or one typed into dashes, as fewer of them than dashes.
+    def self.fixed?(delimiter)
+      equals = delimiter.count('=')
+      equals.positive? && (delimiter.count('-').zero? || equals < delimiter.count('-'))
+    end
+
+    # The equals signs typed into dashes, which aren't part of its width, or none when it's all equals signs.
+    def self.fixing(delimiter)
+      return 0 if delimiter.count('-').zero?
+
+      delimiter.count('=')
+    end
+
+    def fixed?
+      TableColumn.fixed?(delimiter)
+    end
+
+    def alignment
+      if delimiter.start_with?(':') && delimiter.end_with?(':') then :center
+      elsif delimiter.end_with?(':') then :right
+      elsif delimiter.start_with?(':') then :left
+      end
+    end
+
+    def delimiter_cell
+      case alignment
+      when :center then ":#{dashes * (width - 2)}:"
+      when :right then "#{dashes * (width - 1)}:"
+      when :left then ":#{dashes * (width - 1)}"
+      else dashes * width
+      end
+    end
+
+    def pad(cell)
+      padding = [width - TableColumn.display_width(cell), 0].max
+
+      case alignment
+      when :center then "#{' ' * (padding / 2)}#{cell}#{' ' * (padding - (padding / 2))}"
+      when :right then "#{' ' * padding}#{cell}"
+      else "#{cell}#{' ' * padding}"
+      end
+    end
+
+    # The cell cut to fit a fixed column, ending in an ellipsis, or as it is when it fits.
+    def clip(cell)
+      return cell unless fixed? && TableColumn.display_width(cell) > width
+
+      kept = cell.grapheme_clusters.each_with_object(+'') do |grapheme, text|
+        break text if TableColumn.display_width(text + grapheme) > width - 1
+
+        text << grapheme
+      end
+      "#{kept.rstrip}…"
+    end
+
+    # The cell's words as lines that fit the column, each as many as fit, and a word longer than it on a line of its own.
+    def wrap(cell)
+      cell.split(' ').each_with_object([]) do |word, lines|
+        next lines.last << " #{word}" if lines.any? && TableColumn.display_width("#{lines.last} #{word}") <= width
+
+        lines << +word
+      end
+    end
+
+    private
+
+    def dashes
+      return '=' if fixed?
+
+      '-'
+    end
+  end
+end

data/lib/raindown/table/table_formatter.rb

@@ -1,22 +1,43 @@
 # frozen_string_literal: true
 
-require 'unicode/display_width'
+require_relative 'table_column'
 
 module Raindown
-  # Pads every column of each Markdown table to the width of its widest cell.
+  # Pads every column of each Markdown table to the width of its widest cell, but for a column whose delimiter is
+  # equals signs, like |====|, which is as wide as they are, letting a longer cell run past it. A row starting with |+,
+  # like "|+more | |", carries on the row above it, which Raindown joins into its cells when it renders. Its |+ takes
+  # the place of a row's "| ", so its columns line up.
   class TableFormatter
-    DELIMITER_CELL = /\A:?-+:?\z/
+    DELIMITER_CELL = /\A:?[-=]+:?\z/
     FENCE = /\A\s*(```|~~~)/
+    CONTINUATION = /\A\s*\|\+/
 
     def self.rewrite(content:, **)
       new(content:).format
     end
 
+    # The Markdown as Commonmarker reads it: each table's equals signs as dashes, and its + rows joined into the row
+    # above them, each cell carrying on with a space.
+    def self.gfm(markdown)
+      new(content: markdown).gfm
+    end
+
     def initialize(content:)
       @lines = content.lines
     end
 
     def format
+      replace_tables { align(it) }
+    end
+
+    def gfm
+      replace_tables { gfm_table(it) }
+    end
+
+    private
+
+    # The content with each table, outside code, replaced by the block's lines for it.
+    def replace_tables
       output = []
       index = 0
       in_fence = false
@@ -27,7 +48,7 @@ module Raindown
 
         if !in_fence && table_start?(index)
           table_end = find_table_end(index)
-          output.concat(align(@lines[index...table_end]))
+          output.concat(yield(@lines[index...table_end]))
           index = table_end
         else
           output << line
@@ -38,12 +59,26 @@ module Raindown
       output.join
     end
 
-    private
+    # Split on pipes that aren't escaped, dropping the optional outer pipes, or the |+ starting a continuation row.
+    def cells(line)
+      content = line.strip
+      content = content.delete_prefix(row_lead(line).rstrip)
+      content = content.delete_suffix('|') unless content.end_with?('\|')
+
+      content.split(/(?<!\\)\|/, -1).map(&:strip)
+    end
+
+    # How the row's line starts, before its first cell: |+ when it carries on the row above, which is as wide as "| ".
+    def row_lead(line)
+      return '|+' if line.match?(CONTINUATION)
+
+      '| '
+    end
 
     def table_start?(index)
       header = @lines[index]
       delimiter = @lines[index + 1]
-      return false unless header&.include?('|') && delimiter
+      return false unless header&.include?('|') && delimiter && !header.match?(CONTINUATION)
 
       delimiter_cells = cells(delimiter)
       delimiter_cells.any? && delimiter_cells.all? { |cell| cell.match?(DELIMITER_CELL) } &&
@@ -56,79 +91,40 @@ module Raindown
       table_end
     end
 
-    def align(table)
-      indent = table.first[/\A\s*/]
-      rows = table.map { |line| cells(line) }
-      header, delimiter, *body = rows
-      return table if body.any? { |row| row.length > header.length }
-
-      table_lines(indent:, header:, body:, alignments: delimiter.map { |cell| alignment(cell) })
+    def gfm_table(table)
+      header, delimiter, *body = table.map { |line| cells(line) }
+      rows = joined_rows(table.drop(2), header, body)
+      rows.insert(1, delimiter.map { it.tr('=', '-') }).map { "#{table.first[/\A\s*/]}| #{it.join(' | ')} |\n" }
     end
 
-    def table_lines(indent:, header:, body:, alignments:)
-      body = body.map { |row| row + ([''] * (header.length - row.length)) }
-      widths = column_widths(rows: [header, *body])
-
-      [
-        row_line(indent:, cells: header, widths:, alignments:),
-        delimiter_line(indent:, widths:, alignments:),
-        *body.map { |row| row_line(indent:, cells: row, widths:, alignments:) }
-      ].map { |line| "#{line}\n" }
-    end
-
-    # Split on pipes that aren't escaped, dropping the optional outer pipes.
-    def cells(line)
-      content = line.strip
-      content = content.delete_prefix('|')
-      content = content.delete_suffix('|') unless content.end_with?('\|')
-
-      content.split(/(?<!\\)\|/, -1).map(&:strip)
-    end
+    # The rows, each with the + rows below it joined into its cells.
+    def joined_rows(lines, header, body)
+      lines.zip(body).each_with_object([header]) do |(line, row), joined|
+        next joined << row unless line.match?(CONTINUATION)
 
-    def alignment(cell)
-      if cell.start_with?(':') && cell.end_with?(':') then :center
-      elsif cell.end_with?(':') then :right
-      elsif cell.start_with?(':') then :left
+        joined[-1] = joined.last.zip(row).map { |above, more| [above, more].reject { it.to_s.empty? }.join(' ') }
       end
     end
 
-    # Three is the shortest delimiter cell, which also fits ':-:'.
-    def column_widths(rows:)
-      rows.transpose.map { |column| [column.map { |cell| display_width(cell) }.max, 3].max }
-    end
-
-    # Wide characters like CJK and emoji take two columns. Emoji are always measured as two,
-    # instead of guessing from the terminal, so a file formats the same on every machine.
-    def display_width(cell)
-      Unicode::DisplayWidth.of(cell, emoji: :all)
-    end
+    def align(table)
+      header, delimiter, *body = table.map { |line| cells(line) }
+      return table if body.any? { |row| row.length > header.length }
 
-    def row_line(indent:, cells:, widths:, alignments:)
-      padded = cells.each_with_index.map { |cell, i| pad(cell, widths[i], alignments[i]) }
-      "#{indent}| #{padded.join(' | ')} |"
+      rows = [header, *body.map { |row| row + ([''] * (header.length - row.length)) }]
+      aligned_lines(table, rows, TableColumn.all(delimiter, rows))
     end
 
-    def delimiter_line(indent:, widths:, alignments:)
-      dashes = widths.each_with_index.map do |width, i|
-        case alignments[i]
-        when :center then ":#{'-' * (width - 2)}:"
-        when :right then "#{'-' * (width - 1)}:"
-        when :left then ":#{'-' * (width - 1)}"
-        else '-' * width
-        end
+    def aligned_lines(table, rows, columns)
+      indent = table.first[/\A\s*/]
+      lines = rows.zip(table.values_at(0, 2...table.length)).map do |row, line|
+        row_line(indent, line, columns.zip(row).map { |column, cell| column.pad(cell) })
       end
-
-      "#{indent}| #{dashes.join(' | ')} |"
+      lines.insert(1, row_line(indent, table[1], columns.map(&:delimiter_cell)))
     end
 
-    def pad(cell, width, alignment)
-      padding = width - display_width(cell)
-
-      case alignment
-      when :center then "#{' ' * (padding / 2)}#{cell}#{' ' * (padding - (padding / 2))}"
-      when :right then "#{' ' * padding}#{cell}"
-      else "#{cell}#{' ' * padding}"
-      end
+    # The row's line, starting with |+ when it carries on the row above, as the line it was did.
+    def row_line(indent, line, cells)
+      "#{indent}#{row_lead(line)}#{cells.join(' | ')} |\n"
     end
   end
 end

data/lib/raindown/table/written_table.rb

@@ -2,32 +2,47 @@
 
 require 'unicode/display_width'
 
+require_relative 'file_cell'
 require_relative 'markdown_table'
-require_relative 'table_formulas'
+require_relative 'matched_rows'
+require_relative 'table_column'
 
 module Raindown
-  # A table: block's table as it was written, its cells padded as they were, against its file's rows. A formula cell
-  # shows its formula, so it can be edited, when its value's padding was deleted, no longer the width of its column's
-  # header, and keeps showing it, until it's changed from the file's, ignoring whitespace.
+  # A table: block's table as it was written, its cells padded as they were, against its file's cells, as its columns
+  # show them. Each of its rows is matched to the file's row it shows, so a row added or removed above a formula
+  # doesn't move it onto another. A formula's value is no longer lined up when its padding's deleted, the width of its
+  # column's header.
   class WrittenTable
-    def initialize(padded_rows, file)
+    # The delimiter's cells, like ':===', as it was written, or nil when it's not a table yet.
+    attr_reader :delimiter
+
+    def initialize(padded_rows, file, delimiter = nil)
       @padded_rows = padded_rows
       @file = file
       @values = TableFormulas.evaluate(file)
+      @delimiter = delimiter
+      @columns = TableColumn.all(delimiter, file)
     end
 
     # Its rows, as wide as each other, each formula still shown as it's saved being its value, as they're compared with the file's.
     def rows
-      cells.each_with_index.map do |row, row_index|
-        row.each_with_index.map do |cell, column|
-          next @values.dig(row_index, column) if same_formula?(cell, @file.dig(row_index, column))
+      each_cell { |cell, row, column| file_cell(row, column)&.value_from(cell) || cell }
+    end
+
+    # Its rows to write to the file, keeping the file's cell where the table still shows it, like a formula as its
+    # value, or a cell with line breaks on one line.
+    def saved_rows
+      rows.each_with_index.map do |cells, row|
+        cells.each_with_index.map do |cell, column|
+          kept = file_cell(row, column)
+          next kept.saved if kept && MarkdownTable.one_line(kept.value) == cell
 
           cell
         end
       end
     end
 
-    # The row and column of each cell to show as its formula.
+    # The row and column of each cell to show as its formula, or in full.
     def revealed
       cells.each_with_index.flat_map do |row, row_index|
         row.each_index.select { reveal?(row_index, it) }.map { [row_index, it] }
@@ -40,21 +55,39 @@ module Raindown
       @cells ||= @padded_rows.map { |row| Array.new(width_in_cells) { MarkdownTable.cell(row[it].to_s) } }
     end
 
+    def each_cell
+      cells.each_with_index.map { |row, row_index| row.each_with_index.map { |cell, column| yield cell, row_index, column } }
+    end
+
     # As wide as its widest row, as its file's rows are read, so a row still being typed reads the same in both.
     def width_in_cells
       @padded_rows.map(&:length).max
     end
 
-    def reveal?(row, column)
-      formula = @file.dig(row, column)
-      return false unless TableFormulas.formula?(formula)
+    def file_cell(row, column)
+      file_rows[row]&.then { cell_in_file(it, column) }
+    end
 
-      cell = cells[row][column]
-      same_formula?(cell, formula) || (cell == @values.dig(row, column) && squeezed?(row, column))
+    def cell_in_file(file_row, column)
+      saved = @file.dig(file_row, column)
+      FileCell.new(saved:, value: @values.dig(file_row, column), column: @columns[column]) if saved
     end
 
-    def same_formula?(cell, formula)
-      TableFormulas.formula?(formula) && cell.gsub(/\s+/, '') == formula.gsub(/\s+/, '')
+    # The index of each of its rows' file row, or nil for a row that's new.
+    def file_rows
+      @file_rows ||= MatchedRows.new(cells.length, @file.length) { |row, file_row| same_row?(row, file_row) }.file_rows
+    end
+
+    # Whether the table's row shows the file's row, each cell unchanged, or blank where the file has none.
+    def same_row?(row, file_row)
+      cells[row].each_with_index.all? do |cell, column|
+        cell_in_file(file_row, column)&.unchanged_by?(cell) || (cell.empty? && !@file.dig(file_row, column))
+      end
+    end
+
+    def reveal?(row, column)
+      padded = @padded_rows[row][column].to_s
+      file_cell(row, column)&.revealed_by?(cells[row][column], squeezed: squeezed?(row, column), wrapped: padded.include?("\n"))
     end
 
     def squeezed?(row, column)

data/lib/raindown/written.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Raindown
+  # What a node's rewrite writes below its directive: its Markdown, and a comment straight below the directive, like
+  # table:'s "2 rows · 3f2a9c", which its rewrite gets back as comment: the next time it writes. A rewrite can return a
+  # string instead, when it has no comment.
+  class Written
+    attr_reader :markdown, :comment
+
+    def initialize(markdown, comment: nil)
+      @markdown = markdown
+      @comment = comment
+    end
+
+    # Its Markdown, as a rewrite's string would be, like when it's rendered as HTML.
+    def to_s
+      markdown.to_s
+    end
+  end
+end

data/lib/raindown.rb

@@ -16,6 +16,7 @@ require_relative 'raindown/heading_ids'
 require_relative 'raindown/node_blocks'
 require_relative 'raindown/pages'
 require_relative 'raindown/pre_renderer'
+require_relative 'raindown/table/table_formatter'
 require_relative 'raindown/utils'
 require_relative 'raindown/variables'
 require_relative 'raindown/wiki_links'
@@ -89,7 +90,7 @@ module Raindown
 
   # Markdown to HTML, like a document's or a component's slot.
   def commonmark(markdown)
-    doc = Commonmarker.parse(hide_directives(markdown:), options: MARKDOWN_OPTIONS)
+    doc = Commonmarker.parse(hide_directives(markdown: TableFormatter.gfm(markdown)), options: MARKDOWN_OPTIONS)
     preserve_code(doc:)
 
     html = highlight_code? ? doc.to_html(options: HTML_OPTIONS) : unhighlighted_html(doc:)

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindown
-  VERSION = '0.17.2'
+  VERSION = '0.18.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.17.2
+  version: 0.18.0
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-11-08 00:00:00.000000000 Z
+date: 2026-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -254,8 +254,11 @@ files:
 - lib/raindown/server.rb
 - lib/raindown/skeleton.rb
 - lib/raindown/stat.rb
+- lib/raindown/table/file_cell.rb
 - lib/raindown/table/markdown_table.rb
+- lib/raindown/table/matched_rows.rb
 - lib/raindown/table/table.rb
+- lib/raindown/table/table_column.rb
 - lib/raindown/table/table_file.rb
 - lib/raindown/table/table_formatter.rb
 - lib/raindown/table/table_formulas.rb
@@ -339,6 +342,7 @@ files:
 - lib/raindown/wiki_links.rb
 - lib/raindown/workers/worker.rb
 - lib/raindown/workers/workers.rb
+- lib/raindown/written.rb
 - lib/version.rb
 homepage: https://github.com/rainpour/raindown
 licenses: []