raindown 0.17.1 → 0.18.0

data/lib/raindown/table/table.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-require 'csv'
 require 'digest'
 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,25 +27,33 @@ 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/
-    SEPARATORS = { '.csv' => ',', '.tsv' => "\t" }.freeze
+    # 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
 
-    def initialize(data, total: false)
+    def initialize(data = nil, total: false)
       @data = data
       @total = total
     end
 
-    # Written is what it wrote last time, so it can tell which of the table and the file changed since.
-    def rewrite(written: [], metadata: NoMetadata)
+    # 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, comment: nil)
       path = data_path(metadata)
-      data_error(path, metadata) || synced(path, written.map(&:chomp))
+      lines = written.map(&:chomp)
+      create_file(path, lines) if missing_file?(path, metadata)
+      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.
     def render(metadata: NoMetadata)
       path = data_path(metadata)
-      Raindown.commonmark(data_error(path, metadata) || MarkdownTable.format(with_total(TableFormulas.evaluate(read_rows(path)))))
+      error = data_error(path, metadata)
+      return Raindown.commonmark(Problem.alert(error)) if error
+
+      Raindown.commonmark(MarkdownTable.format(with_total(TableFormulas.evaluate(TableFile.read(path)))))
     end
 
     private
@@ -58,24 +68,36 @@ module Raindown
       Dir.pwd
     end
 
+    def missing_file?(path, metadata)
+      TableFile.supported?(path) && Utils.inside?(path, data_root(metadata)) && !File.exist?(path)
+    end
+
+    # 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(/\A>/))
+      rows = STARTER if rows.empty?
+      TableFile.create(path, rows)
+    end
+
     # Why the file can't be a table, or nil when it can.
     def data_error(path, metadata)
-      return "Can't show #{@data.inspect} as a table: only CSV and TSV files can be" unless SEPARATORS.key?(File.extname(path).downcase)
+      return 'Needs a file path to a CSV/TSV that exists or will be created' if @data.to_s.strip.empty?
+      return "#{@data.inspect} must be a file path to a CSV/TSV that exists or will be created" unless TableFile.supported?(path)
       return "Can't show #{@data.inspect} as a table: it's outside the project" unless Utils.inside?(path, data_root(metadata))
 
       "Can't show #{@data.inspect} as a table: no such file" unless File.file?(path)
     end
 
-    def synced(path, written)
-      file = read_rows(path)
+    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(write_rows(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.
@@ -85,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
 
@@ -144,17 +156,6 @@ module Raindown
       row.any? { !it.empty? } && row.all? { it.empty? || it.match?(BOLD) }
     end
 
-    def read_rows(path)
-      rows = CSV.read(path, col_sep: SEPARATORS[File.extname(path).downcase], skip_blanks: true, encoding: Encoding::UTF_8)
-      width = rows.map(&:length).max.to_i
-      rows.map { |row| Array.new(width) { row[it].to_s.strip } }
-    end
-
-    def write_rows(path, rows)
-      File.write(path, rows.map { CSV.generate_line(it, col_sep: SEPARATORS[File.extname(path).downcase]) }.join)
-      rows
-    end
-
     # As the table shows them, so a cell with line breaks hashes the same in both.
     def hash_rows(rows)
       Digest::SHA256.hexdigest(JSON.generate(rows.map { |row| row.map { MarkdownTable.one_line(it.to_s) } }))[0, 6]

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_file.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'fileutils'
+
+module Raindown
+  # The CSV or TSV file behind a table:, as rows of cells as wide as each other, written back in its own format.
+  module TableFile
+    SEPARATORS = { '.csv' => ',', '.tsv' => "\t" }.freeze
+    BYTE_ORDER_MARK = "\uFEFF"
+
+    module_function
+
+    def supported?(path)
+      SEPARATORS.key?(File.extname(path).downcase)
+    end
+
+    def read(path)
+      rows = CSV.read(path, col_sep: separator(path), skip_blanks: true, encoding: 'bom|utf-8')
+      width = rows.map(&:length).max.to_i
+      rows.map { |row| Array.new(width) { row[it].to_s.strip } }
+    end
+
+    # A new file, and the folders it's in, which has no format of its own to keep yet.
+    def create(path, rows)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.binwrite(path, rows.map { CSV.generate_line(without_empty_cells(it), col_sep: separator(path)) }.join)
+    end
+
+    # Keeps the file's line endings and any byte order mark, like Excel's.
+    def write(path, rows)
+      text = File.binread(path).force_encoding(Encoding::UTF_8)
+      options = { col_sep: separator(path), row_sep: text[/\r?\n/] || "\n" }
+      lines = rows.map { CSV.generate_line(without_empty_cells(it), **options) }
+      File.binwrite(path, [(BYTE_ORDER_MARK if text.start_with?(BYTE_ORDER_MARK)), *lines].join)
+      rows
+    end
+
+    def separator(path)
+      SEPARATORS[File.extname(path).downcase]
+    end
+
+    # Empty cells as nil, which CSV leaves empty rather than quoting, but for a row of one, as it would be a blank line.
+    def without_empty_cells(row)
+      return row if row.one?
+
+      row.map { it unless it.empty? }
+    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/watcher/file_watcher.rb

@@ -53,6 +53,7 @@ module Raindown
       def rewrite
         rewrite = Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path))
         rewrite.failures.each { warn "Endpoint check failed: #{it}" }
+        rewrite.problems.each { warn "raindown: #{path}: #{it}" }
         rewrite.changed?
       end
     end

data/lib/raindown/watcher/project.rb

@@ -30,7 +30,7 @@ module Raindown
       def update(path)
         rewrite = Rewriter.update(path:, bare: @bare, execute: @execute, metadata: Pages.for(path))
         puts "[#{name}] Updated #{relative(path)}" if rewrite.changed?
-        rewrite.failures.each { warn "[#{name}] Endpoint check failed: #{it}" }
+        report(rewrite, path)
       rescue StandardError => e
         raise if ENV['RAINDOWN_DEBUG']
 
@@ -40,6 +40,12 @@ module Raindown
 
       private
 
+      # What writing back found wrong: failed endpoint checks, and directives that couldn't run, written in their place.
+      def report(rewrite, path)
+        rewrite.failures.each { warn "[#{name}] Endpoint check failed: #{it}" }
+        rewrite.problems.each { warn "[#{name}] raindown: #{relative(path)}: #{it}" }
+      end
+
       def relative(path)
         File.expand_path(path).delete_prefix(File.join(root, ''))
       end