raindown 0.17.1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c619df9532ee1f014b8837488ac3fe8cc4b3183e7abad17791fb27bb74491499
-  data.tar.gz: aad7d7aefc311af905d14afecd4960096b9cebab871c2da957e4ca05cb85c503
+  metadata.gz: baf58826a9f492870795c2cfb36104ffb214b7494c0b14a2b11aa5f5a7711c64
+  data.tar.gz: 136d56da8dd7574698769f971bcce51662c89f29b28e2b87acb758017f9ee708
 SHA512:
-  metadata.gz: 91c9a12c3bd15d3c9f4ba9e41f645ee5f6ca8447b6208c38d3dd422702acc5f2395161ddb47ae60f248af9707d3c9d53edfa0d4d1dccb78d8aee99987e5c8de3
-  data.tar.gz: cd30f02347aae3834e30c0d77e8ee62b74379f005b844ef8c6b6f03f0638ad11ee7da3980b0978c4145b67dbd3144ce395c4abc7c6d8e2f57102a8e2afeb5534
+  metadata.gz: 2ceb319ab5a5c1482a6d09f98b75e95bf22ece5ca8477b54621ee542691c6de3ee243dc0ef3f580971167cb116990a89a28ae5a4012b50c16ec659a8fcdf5cfa
+  data.tar.gz: 411f712343878e32a1efc7d99932254984e3f0dc45ba91a8b41316fcbf61e9aa0c404ea7d66fc75e0293975d60632e28bde04adcd044d8e3dc36c02ddf9390c2

data/lib/raindown/chart/chart.rb

@@ -33,12 +33,14 @@ module Raindown
 
     # The data is read every time, so the chart follows changes to its file.
     def rewrite(metadata: NoMetadata)
+      return Problem.alert('Needs a file path to a CSV, TSV, JSON or YAML file') if ['', nil].include?(@data)
+
       points = points(metadata:)
       return '' if points.empty?
 
       "```\n#{draw(points).map(&:rstrip).join("\n")}\n```"
     rescue Error => e
-      "Can't chart #{@data.inspect}: #{e.message}"
+      Problem.alert("Can't chart #{@data.inspect}: #{e.message}")
     end
 
     # Each value with its label, or nil for numbers alone.

data/lib/raindown/chart/points.rb

@@ -51,7 +51,7 @@ module Raindown
       end
 
       def read(path)
-        text = File.read(path, encoding: Encoding::UTF_8)
+        text = File.read(path, encoding: 'bom|utf-8')
 
         case File.extname(path).downcase
         when '.csv' then CSV.parse(text, skip_blanks: true)

data/lib/raindown/cli.rb

@@ -169,9 +169,10 @@ module Raindown
         Nodes.load(path)
 
         metadata = Pages.for(path)
-        failures = Rewriter.update(path:, bare:, execute:, metadata:).failures
+        rewrite = Rewriter.update(path:, bare:, execute:, metadata:)
+        warn(*rewrite.problems.map { "raindown: #{path}: #{it}" })
         write(output, Raindown.render_file(path:, bare:, metadata:))
-        check_endpoints(failures)
+        check_endpoints(rewrite.failures)
       end
 
       # Endpoint responses that fail their checks, like status: 200, are listed, and fail the command, for CI.

data/lib/raindown/editing.rb

@@ -18,7 +18,7 @@ module Raindown
     def rewrite_markdown(markdown, path:, bare: false, execute: false)
       Nodes.load(path)
       rewrite = Rewriter.rewrite(content: markdown, path:, bare:, execute:, metadata: Pages.for(path))
-      { output: rewrite.content, warnings: rewrite.failures.map { "Endpoint check failed: #{it}" } }
+      { output: rewrite.content, warnings: rewrite.failures.map { "Endpoint check failed: #{it}" } + rewrite.problems }
     end
   end
 end

data/lib/raindown/node_blocks.rb

@@ -31,13 +31,15 @@ module Raindown
     # <{ Card }>, or <{ :Card }>, which a lowercase name like toc needs, as <{ toc }> is a variable.
     SELF_CLOSING = /\A( {0,3})<\{\s*(?::|(?=[A-Z]))(#{NAME})(?:\s+(.*?))?\s*\}>[ \t]*$/
     BARE_SELF_CLOSING = /\A( {0,3}):(#{NAME})(?:[ \t]+(.*?))?[ \t]*$/
-    # Unquoted text after name:, like YAML's, runs up to the next prop, so title: Hello world limit: 3 has two.
-    UNQUOTED = /.+?(?=[ \t]+\w+(?:=|:[ \t])|[ \t]*\z)/
+    # Unquoted text after name:, like YAML's, runs up to the next prop, so title: Hello world limit: 3 has two. A comma
+    # before the next prop, like data.csv, total: true, separates them like a space, while one in text, like Hello,
+    # world, is part of it.
+    UNQUOTED = /.+?(?=(?:,[ \t]*|[ \t]+)\w+(?:=|:[ \t])|,?[ \t]*\z)/
     # A prop is name=value or name: value, where the value is quoted text, a number, true, false
-    # or a variable like author.name. After name= it's one word.
-    PROP = /(\w+)(?:=|:[ \t]+)("[^"]*"|'[^']*'|(?<==)\S+|#{UNQUOTED})/
+    # or a variable like author.name. After name= it's one word, without a comma after it.
+    PROP = /(\w+)(?:=|:[ \t]+)("[^"]*"|'[^']*'|(?<==)\S+?(?=,?(?:\s|\z))|#{UNQUOTED})/
     # A value before the props is the node's argument.
-    ARG = /\A("[^"]*"|'[^']*'|[^\s"']#{UNQUOTED}|[^\s"'])(?:\s+|\z)/
+    ARG = /\A("[^"]*"|'[^']*'|[^\s"']#{UNQUOTED}|[^\s"'])(?:,\s*|\s+|\z)/
 
     module_function
 
@@ -51,11 +53,33 @@ module Raindown
       variables = Variables.new(front_matter)
 
       spans.map do |span|
-        node = Nodes.instance(span[:class], *args(span[:args], variables, antlers: span[:antlers]))
+        node = node_for(span, args(span[:args], variables, antlers: span[:antlers]))
         span.except(:name, :class, :args, :antlers).merge(node:)
       end
     end
 
+    # The block's node, or a Problem in its place when it can't be made, so the rest of the file still writes back.
+    def node_for(span, (props, values))
+      problem = values_problem(span, values || [])
+      return Nodes.instance(Problem, {}, [problem, span[:open] + 1, span[:name]]) if problem
+
+      Nodes.instance(span[:class], props, *[values].compact)
+    rescue StandardError => e
+      Nodes.instance(Problem, {}, ["Couldn't start: #{e.message}", span[:open] + 1, span[:name]])
+    end
+
+    # A directive with more or fewer values than its node takes, like toc: extra, rather than Ruby's wrong number of
+    # arguments, or nil when it has as many as it takes.
+    def values_problem(span, values)
+      kinds = span[:class].instance_method(:initialize).parameters.map(&:first)
+      required = kinds.count(:req)
+      return if kinds.include?(:rest) || values.length.between?(required, required + kinds.count(:opt))
+
+      return 'Needs a value after it' if values.length < required
+
+      "Takes no value, so it can't read #{values.first.inspect}"
+    end
+
     # Each block like find's, with the node's name, class and props text in place of the node,
     # so a block can be found without making its node, like for a document's outline.
     def spans(lines, bare: false)
@@ -95,10 +119,13 @@ module Raindown
       [marker(lines[block[:open]]), *("#{output}\n".lines unless output.empty?), *close]
     end
 
+    # A node that raises shows why in its place, rather than stopping the page.
     def node_markdown(block, context)
       return Nodes.rendered(block[:node], context) if !block[:writes] || Nodes.html?(block[:node])
 
       Nodes.call(block[:node], :rewrite, **context.to_h).to_s
+    rescue StandardError => e
+      Problem.alert("Couldn't write: #{e.message}")
     end
 
     def marker(line)
@@ -155,7 +182,7 @@ module Raindown
 
     # Text that isn't a prop, like world in title: 'Hello' world or tag=a b, is an error rather than left out.
     def props(text, variables, antlers: true)
-      unread = text.gsub(PROP, '').split
+      unread = text.gsub(PROP, '').delete(',').split
       raise BrokenText, "Can't read #{unread.join(' ')} in #{text.strip}. Text with spaces needs quotes" if unread.any?
 
       text.scan(PROP).to_h { |name, value| [name.to_sym, value(value, variables, antlers:)] }

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,13 +12,22 @@ 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
     end
 
+    # Warnings for the directives that couldn't run, written in their place, each with its line, like
+    # "line 6: toc: takes no value".
+    attr_reader :problems
+
     def initialize(content:, path: nil, bare: false, metadata: NoMetadata)
       @content = content
+      @problems = []
       @bare = BareDirectives.enabled?(path:, content:, bare:)
       @metadata = metadata
     end
@@ -28,21 +38,36 @@ module Raindown
                          .select { |block| block[:writes] }
       return @content if blocks.empty?
 
+      # From the bottom up, so the lines above each block stay where they are, so its problems are put back in order.
       blocks.reverse_each { |block| lines[block[:open]..block[:last]] = block_lines(lines, block) }
+      @problems.reverse!
       lines.join
     end
 
     private
 
     def block_lines(lines, block)
-      context = { document: @content, metadata: @metadata, bare: @bare, written: written_lines(lines, block) }
-      markdown = Nodes.call(block[:node], :rewrite, **context).to_s.chomp
-      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_written(block, context)
+      @problems << block[:node].warning if block[:node].is_a?(Problem)
+      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
+      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
     # at its -->, so what's written below it, like a list, is its own block.
     def delimited(lines, block, written) = [line(lines[block[:open]]), *written, line(lines[block[:close]])]
@@ -55,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/nodes.rb

@@ -6,6 +6,7 @@ require_relative 'js/js_nodes'
 require_relative 'list'
 require_relative 'markdown_nodes'
 require_relative 'node'
+require_relative 'problem'
 require_relative 'stat'
 require_relative 'table/table'
 require_relative 'toc'

data/lib/raindown/problem.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+
+module Raindown
+  # What a directive writes in place of its output when it can't run, like toc: extra, or a node that raised, so the
+  # rest of the file still writes back. In the file it's under its directive, so only its warning says its line and
+  # name. It never starts with the name, like toc:, which would read as a directive once the one above it's deleted.
+  class Problem < Node
+    attr_reader :message, :line
+
+    def initialize(message, line, name = nil)
+      @message = message
+      @line = line
+      @name = name
+      super()
+    end
+
+    # A message as a Markdown alert, which Obsidian, GitHub and Raindown show as a warning, and which can't read as a
+    # directive, as it starts with >.
+    def self.alert(message)
+      "> [!WARNING]\n#{message.lines.map { "> #{it}" }.join}"
+    end
+
+    def rewrite
+      self.class.alert(@message)
+    end
+
+    # For a terminal, or an editor to underline the line, like "line 6: toc: takes no value".
+    def warning
+      ["line #{@line}", @name, @message.sub(/\A[A-Z](?![A-Z])/, &:downcase)].compact.join(': ')
+    end
+  end
+end

data/lib/raindown/rewriter.rb

@@ -9,8 +9,9 @@ module Raindown
   # Rewrites the generated parts of a Markdown file in place before it's rendered:
   # node output, like the TOC, endpoint responses and table alignment.
   module Rewriter
-    # The content written back, and the endpoint checks it failed, like "api.md:3: expected status 200, received 404".
-    Rewrite = Data.define(:original, :content, :failures) do
+    # The content written back, the endpoint checks it failed, like "api.md:3: expected status 200, received 404", and
+    # the directives that couldn't run, like "line 4: toc: takes no value", written in their place.
+    Rewrite = Data.define(:original, :content, :failures, :problems) do
       def changed?
         content != original
       end
@@ -19,9 +20,11 @@ module Raindown
     module_function
 
     def rewrite(content:, path:, bare: false, execute: false, metadata: NoMetadata)
-      injected = NodeInjector.rewrite(content:, path:, bare:, metadata:)
+      injector = NodeInjector.new(content:, path:, bare:, metadata:)
+      injected = injector.call
       endpoints = EndpointRunner.new(content: injected, path:, bare: BareDirectives.enabled?(path:, content: injected, bare:), execute:)
-      Rewrite.new(original: content, content: TableFormatter.rewrite(content: endpoints.rewrite), failures: endpoints.failures)
+      Rewrite.new(original: content, content: TableFormatter.rewrite(content: endpoints.rewrite), failures: endpoints.failures,
+                  problems: injector.problems)
     end
 
     # Writes the file only when it changed.

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