raindown 0.13.0 → 0.15.0

data/lib/raindown/nodes.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'chart/chart'
-require_relative 'files'
+require_relative 'fragments'
 require_relative 'js/js_nodes'
+require_relative 'list'
 require_relative 'markdown_nodes'
 require_relative 'node'
 require_relative 'stat'
@@ -13,15 +14,20 @@ module Raindown
   # Nodes are LowNodes that a node block writes into the Markdown and renders into the HTML.
   # A project keeps them in a .raindown folder, which is loaded with Dirload, beside its JavaScript and Markdown
   # Components, if any.
-  # A node writes Markdown with #replace, and HTML with #render if it has one. Either can take the keywords
-  # document: (the Markdown being rendered), metadata:, bare: and written: (the lines it wrote last time), and gets the
-  # ones it asks for.
+  # Bare or in comments, a node writes back: its Markdown, from #rewrite, is written into the file, and its HTML is from
+  # #render if it has one. In <{ }> it's write-in: it only renders, with #render, which takes the Markdown between its
+  # tags as slot:, in HTML. Either can take the keywords document: (the Markdown being rendered), metadata:, bare: and
+  # written: (the lines it wrote last time), and gets the ones it asks for.
   module Nodes
+    # A write-in node that has no render.
+    class NoRender < StandardError; end
+
     FOLDER = '.raindown'
-    # Lowercase directives for Raindown's own nodes. A project's own TOC, Files, Chart or Table node replaces Raindown's.
-    BUILT_INS = { 'toc' => 'TOC', 'files' => 'Files', 'chart' => 'Chart', 'table' => 'Table' }.freeze
-    # A placeholder for a node's HTML, which stays as it is through Commonmarker and Antlers.
-    PLACEHOLDER = /<!-- raindown:node (\d+) -->/
+    # Lowercase directives for Raindown's own nodes. A project's own TOC, List, Chart or Table node replaces Raindown's.
+    BUILT_INS = { 'toc' => 'TOC', 'list' => 'List', 'chart' => 'Chart', 'table' => 'Table' }.freeze
+    # A placeholder for a node's HTML, which stays as it is through Commonmarker and Antlers, with its slot's HTML, as a
+    # fragment, when it has one.
+    PLACEHOLDER = /<!-- raindown:node (\d+)(?: slot (\d+))? -->/
 
     module_function
 
@@ -63,21 +69,21 @@ module Raindown
 
     # A Ruby node of the name, or else a JavaScript one, or else a Markdown one.
     def loaded_class(name)
-      klass = Object.const_get(name) if Object.const_defined?(name)
+      klass = Object.const_get(name) if name.match?(/\A[A-Z]/) && Object.const_defined?(name)
       return klass if node?(klass)
 
       JSNodes.node_class(name) || MarkdownNodes.node_class(name)
     end
 
     # A LowNode, or one of Raindown's own nodes, that writes Markdown. In an app, LowNodes are also routes and pages,
-    # which don't have replace, so text like "Note:" only starts a block when the Note node writes something.
+    # which don't have rewrite, so text like "Note:" only starts a block when the Note node writes something.
     def node?(klass)
-      return false unless klass.is_a?(Class) && klass.method_defined?(:replace)
+      return false unless klass.is_a?(Class) && klass.method_defined?(:rewrite)
 
       klass < Node || (defined?(::LowNode) && klass < ::LowNode) || false
     end
 
-    # Calls a node's replace or render with the context keywords it takes.
+    # Calls a node's rewrite or render with the context keywords it takes.
     def call(node, name, **context)
       parameters = node.method(name).parameters
       return node.public_send(name, **context) if parameters.any? { |type, _| type == :keyrest }
@@ -99,24 +105,56 @@ module Raindown
       list[instances[key]]
     end
 
-    def placeholder(node)
-      "<!-- raindown:node #{list.index(node)} -->"
+    # Renders the node where it is, as a fragment, so its headings are part of the page, or through a placeholder, once
+    # the page is HTML, when its render takes html:, the page's HTML, like TOC's.
+    def rendered(node, context, slot: '')
+      raise NoRender, "#{node.class.name} has no render, so it can't be write-in: write it bare or in comments" unless renders?(node)
+      return placeholder(node, slot:) if !template?(node.class) && takes?(node, :render, :html)
+
+      Fragments.add(html(node, context, slot:))
+    end
+
+    def takes?(node, method_name, keyword)
+      node.method(method_name).parameters.any? { |_, name| name == keyword }
     end
 
-    # Swaps each placeholder for its node's HTML.
-    def render_placeholders(html, **context)
-      html.gsub(PLACEHOLDER) { html(list[::Regexp.last_match(1).to_i], **context) }
+    # Whether the node's class has a template, like a Raindeer .rbx component, which renders in place of render.
+    def template?(klass)
+      klass.respond_to?(:template) && !klass.template.nil?
     end
 
-    def html(node, **context)
-      return node.render_template(props: {}).to_s if node.class.respond_to?(:template) && node.class.template
+    def placeholder(node, slot: '')
+      return "<!-- raindown:node #{list.index(node)} -->" if slot.empty?
 
-      call(node, :render, **context).to_s
+      "<!-- raindown:node #{list.index(node)} slot #{Fragments.store(slot)} -->"
+    end
+
+    # Swaps each placeholder for its node's HTML, given the page's HTML and its slot, the HTML between its tags in <{ }>,
+    # which can hold components' fragments.
+    def render_placeholders(page_html, context)
+      page_html.gsub(PLACEHOLDER) do
+        match = ::Regexp.last_match
+        slot = match[2] ? Fragments.list[match[2].to_i] : ''
+        Fragments.fill(html(list[match[1].to_i], context, slot:, html: page_html))
+      end
     end
 
-    # Whether the node renders its own HTML rather than the HTML of its Markdown.
+    def html(node, context, **keywords)
+      return node.render_template(props: {}).to_s if template?(node.class)
+
+      call(node, :render, **context.to_h, **keywords).to_s
+    end
+
+    # Whether the node renders its own HTML rather than the HTML of its Markdown, which Raindown's nodes render by default.
     def html?(node)
-      node.respond_to?(:render) || (node.class.respond_to?(:template) && !node.class.template.nil?)
+      return true if template?(node.class)
+
+      node.respond_to?(:render) && node.method(:render).owner != Node
+    end
+
+    # Whether the node renders at all, so it can be write-in, in <{ }>.
+    def renders?(node)
+      node.respond_to?(:render) || html?(node)
     end
 
     def instances

data/lib/raindown/pages.rb

@@ -5,7 +5,7 @@ require_relative 'page'
 require_relative 'utils'
 
 module Raindown
-  # The metadata of a project's Markdown files, which list: and files: list by tag.
+  # The metadata of a project's Markdown files, which list: lists by tag.
   # Ported from Raindeer's Rain::Pages, and takes the same Dirload metadata.
   #
   # Each file is tagged with its front matter, like "tags: [ruby, docs]" or "date: 2099", and by its path,
@@ -65,7 +65,7 @@ module Raindown
     def initialize(root:, metadata:, render_options: {}, eager: false)
       @root = root
       @render_options = render_options
-      @file_paths = metadata.file_types.values_at(*EXTENSIONS).flatten.compact
+      @file_paths = filtered_paths(metadata:)
       load_metadata if eager
     end
 
@@ -82,6 +82,11 @@ module Raindown
 
     private
 
+    # The Markdown files in Dirload's metadata, only those under the root path.
+    def filtered_paths(metadata:)
+      metadata.file_types.values_at(*EXTENSIONS).flatten.compact.select { it.start_with?("#{@root}/") }
+    end
+
     def metadata
       load_metadata unless @metadata
       @metadata
@@ -103,8 +108,7 @@ module Raindown
     end
 
     def process(file_path:)
-      metadata = implicit_metadata(file_path:).merge(front_matter(file_path))
-      @metadata[file_path] = metadata
+      metadata = @metadata[file_path] = implicit_metadata(file_path:).merge(front_matter(file_path))
       metadata.each { |type, tag| Array(tag).each { |item| tag(type:, tag: item, file_path:) } }
     end
 

data/lib/raindown/pre_renderer.rb

@@ -5,31 +5,33 @@ require_relative '../elements'
 require_relative 'bare_directives'
 require_relative 'code'
 require_relative 'code_blocks'
+require_relative 'context'
 require_relative 'front_matter'
 
 module Raindown
   # Renders the directives whose output is Markdown, before Commonmarker reads it: variables, loops, conditions and lists.
   # So a loop's items become one Markdown list or table, and a heading's id and its entry in a table of contents
   # come from its text, like "# Notes for {name}" becoming "Notes for Mark" with the id "notes-for-mark".
-  # Nodes like toc: and files: render before this. Components and endpoints render here too, as fragments of HTML
-  # that Raindown puts back once the document is HTML.
+  # Nodes bare or in comments, like toc: and list:, render before this. Nodes in <{ }> and endpoints render here, as
+  # fragments of HTML that Raindown puts back once the document is HTML.
   module PreRenderer
     BLOCK_DIRECTIVES = %w[for if list].freeze
     # A for, if or list directive alone on its line, which leaves no line behind, so a loop's list items stay together.
-    BLOCK_LINE = /^[ \t]*(<\{\s*:?(?:#{BLOCK_DIRECTIVES.join('|')})\b[^}]*\}>)[ \t]*\n/
+    # A self-closing <{ :list folder: 'notes' }> isn't one, as only an open tag has props after its name.
+    BLOCK_LINE = /^[ \t]*(<\{\s*(?:(?:#{BLOCK_DIRECTIVES.join('|')}):[^}]*|:(?:#{BLOCK_DIRECTIVES.join('|')})\s*)\}>)[ \t]*\n/
     # An endpoint's directive or end tag in a comment, which renders as it would in Antlers' delimiters.
     ENDPOINT_COMMENT = /\A( {0,3})<!--\s*(endpoint:.*?|:endpoint)\s*-->/
 
     module_function
 
-    def render(markdown, variables:, metadata: {}, bare: false)
-      markdown = BareDirectives.expand(markdown) if bare
+    def render(markdown, variables:, context: Context.new)
+      markdown = BareDirectives.expand(markdown) if context.bare
       markdown = delimited_endpoints(markdown) if markdown.include?('<!--')
       return markdown unless markdown.include?('{')
 
       markdown = Code.hide_braces(markdown.dup.force_encoding('UTF-8'))
       body = FrontMatter.parse(markdown).last
-      "#{markdown.delete_suffix(body)}#{render_body(body, variables, metadata)}"
+      "#{markdown.delete_suffix(body)}#{render_body(body, variables, context)}"
     end
 
     # The endpoints in comments in Antlers' delimiters, which the template pass renders, leaving code as it is.
@@ -46,16 +48,17 @@ module Raindown
       lines.join
     end
 
-    def render_body(body, variables, metadata)
+    def render_body(body, variables, context)
       template = body.gsub(BLOCK_LINE, '\1')
       return body unless template.include?('{')
 
       # Antlers strips the whitespace around a template, which can be Markdown, like an indented code block.
       leading = template[/\A\s*/]
       trailing = template[/\s*\z/]
-      # Components and endpoints render here too, where loop variables are in scope, and keep their HTML as fragments.
-      elements = Antlers::Elements[:html, :var, :if, :for] + Elements[:list, :endpoint, :prop_component, :slot_component]
-      rendered = Antlers.render(ast: Antlers.ast(template:, elements:), current_binding: variables.binding, metadata:)
+      # Write-in nodes and endpoints render here too, where loop variables are in scope, and keep their HTML as
+      # fragments.
+      elements = Antlers::Elements[:html, :var, :if, :for] + Elements[:write_in, :endpoint]
+      rendered = Antlers.render(ast: Antlers.ast(template:, elements:), current_binding: variables.binding, context:)
 
       "#{leading}#{rendered}#{trailing}"
     end

data/lib/raindown/projects.rb

@@ -13,6 +13,7 @@ module Raindown
     IGNORED = %w[node_modules vendor tmp pkg build dist coverage].freeze
     # Ruby nodes and JavaScript Components.
     NODE_EXTENSIONS = ['.rb', '.rbx', *JSNodes::EXTENSIONS].freeze
+    VAULT_FOLDER = '.obsidian'
 
     module_function
 
@@ -23,11 +24,11 @@ module Raindown
     end
 
     # The folders below a directory with a .raindown folder. Only folders are walked, leaving out ignored, linked and
-    # gitignored ones, so it stays quick in a big folder like ~/dev.
+    # gitignored ones, so it stays quick in a big folder like ~/dev, and vaults, which their editor writes back to.
     def project_folders(directory, gitignore = Gitignore.new(directory))
       Dir.glob('*/', base: directory).flat_map do |folder|
         path = File.join(directory, folder.chomp('/'))
-        next [] if ignored?(folder.chomp('/')) || File.symlink?(path) || gitignore.ignores?(path)
+        next [] if ignored?(folder.chomp('/')) || File.symlink?(path) || gitignore.ignores?(path) || vault?(path)
 
         inside = project_folders(path, Gitignore.new(path, gitignore))
         next inside unless project?(path)
@@ -44,13 +45,13 @@ module Raindown
     end
 
     # The project's Markdown files, sorted, leaving out ignored folders. The projects inside it are left out too,
-    # since they have nodes of their own.
+    # since they have nodes of their own, and vaults, which their editor writes back to.
     def files(root)
       files = []
 
       Find.find(root) do |path|
         if File.directory?(path)
-          Find.prune if path != root && (ignored?(File.basename(path)) || project?(path))
+          Find.prune if path != root && (ignored?(File.basename(path)) || project?(path) || vault?(path))
         elsif markdown?(path, root:)
           files << path
         end
@@ -82,6 +83,25 @@ module Raindown
       File.directory?(File.join(folder, Nodes::FOLDER))
     end
 
+    # Whether a folder's an Obsidian vault, whose plugin runs a Raindown of its own, so one watching a folder above it
+    # leaves it alone, while one pointed at the vault itself doesn't.
+    def vault?(folder)
+      File.directory?(File.join(folder, VAULT_FOLDER))
+    end
+
+    # Whether a path's in a vault below the directory, which isn't the directory itself.
+    def vault_below?(path, directory)
+      tops = [File.expand_path(directory), File.realpath(directory)]
+      folders = []
+      folder = File.dirname(File.expand_path(path))
+      until tops.include?(folder) || folder == File.dirname(folder)
+        folders << folder
+        folder = File.dirname(folder)
+      end
+
+      tops.include?(folder) && folders.any? { vault?(it) }
+    end
+
     def ignored?(folder)
       folder.start_with?('.') || IGNORED.include?(folder)
     end

data/lib/raindown/rewriter.rb

@@ -2,7 +2,7 @@
 
 require_relative 'node_injector'
 require_relative 'endpoint/endpoint_runner'
-require_relative 'table_formatter'
+require_relative 'table/table_formatter'
 require_relative 'utils'
 
 module Raindown

data/lib/raindown/stat.rb

@@ -23,7 +23,7 @@ module Raindown
                '9' => ['█▀█', '▀▀█', '▀▀▀'], '-' => ['   ', '▀▀▀', '   '], '+' => [' ▄ ', '▀█▀', '   '],
                '.' => [' ', ' ', '▀'], ',' => [' ', ' ', '▀'] }.freeze
 
-    def replace(metadata: NoMetadata) = "```\n#{card_lines(metadata:).join("\n")}\n```"
+    def rewrite(metadata: NoMetadata) = "```\n#{card_lines(metadata:).join("\n")}\n```"
 
     # The number in block digits, then the label, as a card on the Dashboard shows them.
     def card_lines(metadata: NoMetadata)

data/lib/raindown/table/markdown_table.rb

@@ -11,19 +11,27 @@ module Raindown
     module_function
 
     def format(rows)
+      return '' if rows.empty?
+
       header, *body = rows.map { |row| "| #{row.map { escape(it) }.join(' | ')} |" }
       [header, "|#{Array.new(rows.first.length, '---').join('|')}|", *body].join("\n")
     end
 
     # The rows of the table in the lines, leaving out its separator, or none when they aren't a table.
     def parse(lines)
+      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.
+    def padded_rows(lines)
       return [] unless lines[1]&.strip&.match?(SEPARATOR)
 
-      [lines[0], *lines.drop(2)].take_while { it.strip.start_with?('|') }.map { cells(it.strip) }
+      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) }
     end
 
-    def cells(line)
-      line.delete_prefix('|').delete_suffix('|').split(PIPE, -1).map { it.strip.gsub('\|', '|') }
+    def cell(padded)
+      padded.strip.gsub('\|', '|')
     end
 
     def escape(cell)

data/lib/raindown/table/table.rb

@@ -6,6 +6,8 @@ require 'json'
 
 require_relative '../node'
 require_relative 'markdown_table'
+require_relative 'table_formulas'
+require_relative 'written_table'
 
 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
@@ -17,42 +19,120 @@ module Raindown
   #   | Ada  | engineer |
   #   | Lin  | design   |
   # Edit the table and its rows are written back to the file, or edit the file and the table's written again. When
-  # both changed, neither is, and the table's comment says so until they match again.
+  # both changed, neither is, and the table's comment says so until they match again. With total: true, a bold row
+  # below the table sums its columns of numbers, which is worked out each time and never written to the file. Formula
+  # 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
+    BOLD = /\A\*\*.*\*\*\z/
 
-    def initialize(data)
+    def initialize(data, 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 replace(written: [], metadata: NoMetadata)
-      path = File.expand_path(@data.to_s, metadata.respond_to?(:root) ? metadata.root : Dir.pwd)
-      return "Can't show #{@data.inspect} as a table: only CSV and TSV files can be" unless SEPARATORS.key?(File.extname(path).downcase)
-      return "Can't show #{@data.inspect} as a table: no such file" unless File.file?(path)
+    def rewrite(written: [], metadata: NoMetadata)
+      path = data_path(metadata)
+      data_error(path) || synced(path, written.map(&:chomp))
+    end
 
-      synced(path, written.map(&:chomp))
+    # 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) || MarkdownTable.format(with_total(TableFormulas.evaluate(read_rows(path)))))
     end
 
     private
 
+    def data_path(metadata)
+      File.expand_path(@data.to_s, metadata.respond_to?(:root) ? metadata.root : Dir.pwd)
+    end
+
+    # Why the file can't be a table, or nil when it can.
+    def data_error(path)
+      return "Can't show #{@data.inspect} as a table: only CSV and TSV files can be" unless SEPARATORS.key?(File.extname(path).downcase)
+
+      "Can't show #{@data.inspect} as a table: no such file" unless File.file?(path)
+    end
+
     def synced(path, written)
       file = read_rows(path)
+      shown = TableFormulas.evaluate(file)
       synced_hash = written.first&.[](COMMENT, 1)
-      table = MarkdownTable.parse(written.drop(1))
-      return markdown(file) if synced_hash.nil? || table.empty? || [synced_hash, hash_rows(file)].include?(hash_rows(table))
-      return markdown(write_rows(path, table)) if hash_rows(file) == synced_hash
+      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_formulas(table.rows, file, shown)), table.revealed) 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")
     end
 
-    def markdown(rows)
+    # 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.
+    def unchanged?(rows, synced_hash, shown)
+      synced_hash.nil? || rows.empty? || [synced_hash, hash_rows(shown)].include?(hash_rows(rows))
+    end
+
+    # 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.reject { total_row?(it.map(&:strip)) }].compact
+    end
+
+    def markdown(rows, revealed = [])
       return '' if rows.empty?
 
+      shown = TableFormulas.evaluate(rows)
       count = rows.length - 1
-      "<!-- table #{count} row#{'s' unless count == 1} · #{hash_rows(rows)} -->\n#{MarkdownTable.format(rows)}"
+      table = MarkdownTable.format(with_total(with_revealed(shown, rows, revealed)))
+      "<!-- table #{count} row#{'s' unless count == 1} · #{hash_rows(shown)} -->\n#{table}"
+    end
+
+    # The values, but for each revealed cell, which shows its formula.
+    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 formula in each cell still showing its value.
+    def with_formulas(table, file, shown)
+      table.each_with_index.map do |row, row_index|
+        row.each_with_index.map do |cell, column|
+          formula = file.dig(row_index, column)
+          next formula if TableFormulas.formula?(formula) && shown.dig(row_index, column) == cell
+
+          cell
+        end
+      end
+    end
+
+    def with_total(rows)
+      return rows unless @total && rows.length > 1
+
+      body = rows.drop(1)
+      sums = rows.first.each_index.map { |column| sum_cells(body.map { it[column].to_s }) }
+      sums[0] ||= 'Total'
+      [*rows, sums.map { bold_cell(it) }]
+    end
+
+    # The sum of cells that are all numbers, or blank, to the most decimal places any has, or nil when they aren't.
+    def sum_cells(cells)
+      numbers = cells.reject(&:empty?)
+      return if numbers.empty? || !numbers.all? { it.match?(TableFormulas::NUMBER) }
+
+      TableFormulas.sum(numbers)
+    end
+
+    def bold_cell(text)
+      return '' unless text
+
+      "**#{text}**"
+    end
+
+    # The total row it wrote, its cells bold or blank, which isn't one of the file's rows.
+    def total_row?(row)
+      row.any? { !it.empty? } && row.all? { it.empty? || it.match?(BOLD) }
     end
 
     def read_rows(path)

data/lib/raindown/table/table_formulas.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Raindown
+  # Formula cells in a table's rows, like =SUM(B), by its column's letter, or =sum(Price), by its header, worked out
+  # as spreadsheets do: the numbers in the column's other rows below the header, leaving out other formulas. Any other
+  # formula, or one naming no column, like one still being typed, is left as it's written.
+  module TableFormulas
+    NUMBER = /\A-?\d+(?:\.\d+)?\z/
+    SUM = /\A=SUM\(\s*([^)]+?)\s*\)\z/i
+
+    module_function
+
+    def evaluate(rows)
+      header, *body = rows
+      return rows unless header
+
+      [header, *body.map { |row| row.map { sum_formula(it, header, body) || it } }]
+    end
+
+    def formula?(cell)
+      cell.to_s.match?(SUM)
+    end
+
+    # The sum of the numbers, to the most decimal places any of them has.
+    def sum(numbers)
+      places = numbers.map { it[/\.(\d+)/, 1].to_s.length }.max.to_i
+      total = numbers.sum { Rational(it) }
+      return total.round.to_s if places.zero?
+
+      format("%.#{places}f", total)
+    end
+
+    def sum_formula(cell, header, body)
+      column_ref = cell[SUM, 1]
+      return unless column_ref
+
+      column = header.index { it.casecmp?(column_ref) } || column_index(column_ref)
+      return unless column && column < header.length
+
+      sum(body.map { it[column].to_s }.select { it.match?(NUMBER) })
+    end
+
+    # A column's letters as its index, like B as 1 and AA as 26, or nil when they aren't letters.
+    def column_index(letters)
+      return unless letters.match?(/\A[A-Z]{1,3}\z/i)
+
+      letters.upcase.chars.reduce(0) { |index, letter| (index * 26) + letter.ord - 64 } - 1
+    end
+  end
+end

data/lib/raindown/table/written_table.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+require_relative 'markdown_table'
+require_relative 'table_formulas'
+
+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.
+  class WrittenTable
+    def initialize(padded_rows, file)
+      @padded_rows = padded_rows
+      @file = file
+      @values = TableFormulas.evaluate(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))
+
+          cell
+        end
+      end
+    end
+
+    # The row and column of each cell to show as its formula.
+    def revealed
+      cells.each_with_index.flat_map do |row, row_index|
+        row.each_index.select { reveal?(row_index, it) }.map { [row_index, it] }
+      end
+    end
+
+    private
+
+    def cells
+      @cells ||= @padded_rows.map { |row| Array.new(width_in_cells) { MarkdownTable.cell(row[it].to_s) } }
+    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)
+
+      cell = cells[row][column]
+      same_formula?(cell, formula) || (cell == @values.dig(row, column) && squeezed?(row, column))
+    end
+
+    def same_formula?(cell, formula)
+      TableFormulas.formula?(formula) && cell.gsub(/\s+/, '') == formula.gsub(/\s+/, '')
+    end
+
+    def squeezed?(row, column)
+      width(@padded_rows[row][column]) != width(@padded_rows.first[column])
+    end
+
+    def width(padded)
+      Unicode::DisplayWidth.of(padded.to_s, emoji: :all)
+    end
+  end
+end

data/lib/raindown/toc.rb

@@ -14,7 +14,7 @@ module Raindown
     IGNORED = %r{<!--.*?-->|<script\b.*?</script\s*>}mi
     TAG = /<[^>]*>/
 
-    def replace(document:, metadata: nil, bare: false)
+    def rewrite(document:, metadata: nil, bare: false)
       headings = headings(markdown: document, metadata:, bare:)
       return '' if headings.empty?
 
@@ -45,7 +45,7 @@ module Raindown
 
     # The document's headings, from its final HTML, or else by rendering it with its components.
     def headings(markdown:, html: nil, metadata: nil, bare: false)
-      html ||= Fragments.collect { Raindown.assembled(markdown:, metadata: metadata || NoMetadata, bare:) }
+      html ||= Fragments.collect { Raindown.assembled(Context.new(document: markdown, metadata: metadata || NoMetadata, bare:)) }
 
       html.gsub(IGNORED, '').scan(HEADING).map do |level, *ids, content|
         { level: level.to_i, text: CGI.unescapeHTML(content.gsub(TAG, '')).strip, id: CGI.unescapeHTML(ids.compact.first) }

data/lib/raindown/tui/navigator/commands.rb

@@ -90,7 +90,7 @@ module Raindown
       # and the files and endpoints are read again for the files added, removed or changed. When endpoints run as files
       # are written back, like with -x, the screen says so while they do, as they can take a while.
       def watched(paths)
-        changes = Watcher.changes(paths, root:)
+        changes = Watcher.changes(paths, directory: root, root: plain_root)
         return reload if changes.any?(&:nodes?)
         return if changes.empty?
 
@@ -100,6 +100,12 @@ module Raindown
         Wait.new(message: "Writing back #{relative(saved.first)}...", task: -> { write_back_all(saved) })
       end
 
+      # A file outside a project belongs to the folder only when it has no projects, as in a folder of notes. In one
+      # like ~/dev, only its projects are written back to, as they're all that's shown.
+      def plain_root
+        root if @workers.roots.empty?
+      end
+
       def write_back_all(files)
         files.each { write_back_saved(it) }
         @files.load