raindown 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be9fc3af39c4d6f20b00b691a14582626448ac903a01aa129a2f33911553a76f
-  data.tar.gz: d0bf1eea7f8996adb29d97eeeaeda1c38ad16739df7724704ab1402b1bd2c723
+  metadata.gz: b35949f91c9cf54ccb1ab0fe6b0e24a2e9529f830cd648f097015aba55acb135
+  data.tar.gz: 3b62d3623ea255e6767b349a3210c48a331bcdae8282d9a365adea680e2242e8
 SHA512:
-  metadata.gz: b6b4305e373de95235142d2e030849aac517d724232194bd68eb2c16cef7c81dd9594ccc8a80b2cd7d8042af045818773d1059c8d30caef634f0722ed35cd6d4
-  data.tar.gz: 593a219070643268ddd2c52a25aa34d0fe76d62f1074c2a3a263dddf72407d4b03c3a13113100e684ee19c6168a15525e059bf26c118ea6bca680c7112c3ee62
+  metadata.gz: c63653585217df9c3129b554f0619fe024916a73c7eaea2fcad53199ee2f790fbece26bf90c956fa716109080b6c457048acbc3bb39fa97d3520765b4d9ff47d
+  data.tar.gz: 1f6e1d91403fcfbf9f2968885bf94a227a1a114084a65bb8735c7dbdff4479b622f8fa3ea17fab42f7e3cc826372c726d1d90f137b50eac32a92f531b935f20a

data/lib/raindown/cli.rb

@@ -76,6 +76,8 @@ module Raindown
     end
 
     def self.run(argv)
+      # Markdown is UTF-8 whatever the locale, as an app opened from the Dock, like Obsidian, starts Raindown without one.
+      Encoding.default_external = Encoding::UTF_8
       return if command(argv)
 
       # Without a path, like "raindown", "raindown -x" or "raindown watch", it's the current directory.

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/table/markdown_table.rb

@@ -19,13 +19,19 @@ module Raindown
 
     # 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,13 +19,18 @@ 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.
@@ -35,7 +42,7 @@ module Raindown
     # 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(read_rows(path)))
+      Raindown.commonmark(data_error(path) || MarkdownTable.format(with_total(TableFormulas.evaluate(read_rows(path)))))
     end
 
     private
@@ -53,20 +60,79 @@ module Raindown
 
     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

@@ -15,7 +15,7 @@ module Raindown
     TAG = /<[^>]*>/
 
     def rewrite(document:, metadata: nil, bare: false)
-      headings = headings(markdown: document, metadata:, bare:)
+      headings = headings_below_title(markdown: document, metadata:, bare:)
       return '' if headings.empty?
 
       min_level = headings.map { |heading| heading[:level] }.min
@@ -27,7 +27,7 @@ module Raindown
 
     # With the document's final HTML, the headings include ones its components render.
     def render(document:, html: nil, metadata: nil, bare: false)
-      items = headings(markdown: document, html:, metadata:, bare:).map do |heading|
+      items = headings_below_title(markdown: document, html:, metadata:, bare:).map do |heading|
         "<li class='h#{heading[:level]}'><a href='##{heading[:id]}'>#{CGI.escapeHTML(heading[:text])}</a></li>"
       end
 
@@ -43,6 +43,14 @@ module Raindown
       HTML
     end
 
+    # A lone top-level heading that starts the document is its title, so it's left out when there are headings below it.
+    def headings_below_title(**)
+      title, *below = headings = headings(**)
+      return headings if below.empty? || title[:level] != 1 || below.any? { it[:level] == 1 }
+
+      below
+    end
+
     # 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(Context.new(document: markdown, metadata: metadata || NoMetadata, bare:)) }

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

data/lib/raindown/watcher/changes.rb

@@ -19,10 +19,12 @@ module Raindown
       Listen.to(directory, ignore: IGNORE) { |modified, added, removed| yield(modified + added + removed) }
     end
 
-    # The changes among the paths, by the project each is in, the nearest one above it, or else the root, when there is
-    # one, leaving out files that are neither nodes nor Markdown, or are in ignored folders.
-    def self.changes(paths, root: nil)
+    # The changes among the paths in the directory, by the project each is in, the nearest one above it, or else the
+    # root, when there is one, leaving out files that are neither nodes nor Markdown, or are in ignored folders or vaults.
+    def self.changes(paths, directory:, root: nil)
       paths.filter_map do |path|
+        next if Projects.vault_below?(path, directory)
+
         project = Projects.root(path) || root || next
         next Change.new(root: project, path:, nodes: true) if Projects.node?(path, root: project)
 

data/lib/raindown/watcher/supervisor.rb

@@ -42,7 +42,7 @@ module Raindown
       # endpoint's request with -x, only holds up its own project. Without fork, the projects share this process, so
       # they're taken in turn.
       def handle(paths)
-        Watcher.changes(paths).each do |change|
+        Watcher.changes(paths, directory:).each do |change|
           next unless change.nodes? || change.saved?
           next take(change) unless fork?
 

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.16.0
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-11-06 00:00:00.000000000 Z
+date: 2026-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: commonmarker
   requirement: !ruby/object:Gem::Requirement
@@ -254,7 +254,9 @@ files:
 - lib/raindown/stat.rb
 - lib/raindown/table/markdown_table.rb
 - lib/raindown/table/table.rb
-- lib/raindown/table_formatter.rb
+- lib/raindown/table/table_formatter.rb
+- lib/raindown/table/table_formulas.rb
+- lib/raindown/table/written_table.rb
 - lib/raindown/toc.rb
 - lib/raindown/tui.rb
 - lib/raindown/tui/blueprints/blueprints_renderer.rb