raindown 0.17.0 → 0.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2abf28897b1c392d34ec786d7abad550414050fe3f45949929240fa31453cf23
-  data.tar.gz: edafdc330bddeaf1b76a4d6538b1e3db9241c1758526d0076b0ffe76d5aac32a
+  metadata.gz: ce48803b10f9d818849d224607930c3f41c63d66a830e9da2fa6ef43c877a5cb
+  data.tar.gz: 040a45c39fc4d1439d80af01c7c6d9d937d24850f69093c9e478c79964305bb6
 SHA512:
-  metadata.gz: 5ce17ac9171dfa2d3a37311698f53e89390eccd2d3105a60adef58136f6bf4f741162ecd6eea0edc10a341434aaa58b1b8832e1971cc1ae3498771255616e3ce
-  data.tar.gz: 15ff81a860a3403f8bca98ca63052be5d8ff1cc9feda5da235f6b753ffd92f74ba313471ac60d7b61c59fb7c84f38bd05e8dd7dfa68877a66d84bd5251499217
+  metadata.gz: 1e1109ca3ea21b6ae214b5d3bff967d2936e53b23ea0c71b1ca97bbcc208ac4249f5b14d151fb9a94f575d56fbdbfde12ccba1c12bf1b4a287ab632508df1260
+  data.tar.gz: 22ba4b827f93a2c9edaf6d21c7be2e8d6916b5a95627e2f29b1309eec01eb6de59cb126ab9874a725ca3b089813529ec7b902501541c06661e5d87922ca9ee41

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

@@ -16,8 +16,13 @@ module Raindown
       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,7 +33,9 @@ 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
 
@@ -36,13 +43,23 @@ module Raindown
 
     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
+      markdown = node_markdown(block, context)
       written = markdown.empty? ? [] : "#{markdown}\n".lines
       return [line(lines[block[:open]]), *bare(written, block)] unless block[:close]
 
       delimited(lines, block, written)
     end
 
+    # A node that raises writes why in its place, like a Problem, so the rest of the file still writes back.
+    def node_markdown(block, context)
+      @problems << block[:node].warning if block[:node].is_a?(Problem)
+      Nodes.call(block[:node], :rewrite, **context).to_s.chomp
+    rescue StandardError => e
+      problem = Problem.new("Couldn't write: #{e.message}", block[:open] + 1)
+      @problems << problem.warning
+      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]])]

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/server.rb

@@ -13,7 +13,7 @@ module Raindown
   #   {"id": 1, "path": "/notes/a.md", "markdown": "<!-- toc: -->", "rewrite": true}
   #   {"id": 1, "output": "<!-- toc: -->\n- ...", "warnings": []}
   # Rewriting answers like --stdin --rewrite, with "execute" like -x, and otherwise it's HTML, like --stdin. An error's
-  # answered as {"id": 1, "error": "raindown: /notes/a.md: ..."}, like the CLI writes it.
+  # answered as {"id": 1, "error": "/notes/a.md: ..."}, like the CLI writes it.
   # Each project renders in a worker of its own, which starts again when its .raindown folder changes, so its nodes,
   # config and schemas are never stale. Without fork, as on Windows, node changes need the server started again.
   class Server
@@ -33,13 +33,14 @@ module Raindown
 
     private
 
+    # Any error is the answer, as an editor's only got its server, and one note can't be allowed to stop it.
     def answer(line)
       request = JSON.parse(line)
       { id: request['id'], **edit(request) }
-    rescue JSON::ParserError, KeyError => e
-      { id: request&.dig('id'), error: "raindown: #{e.message}" }
     rescue Workers::Worker::Error => e
-      { id: request['id'], error: "raindown: #{request['path']}: #{e.message}" }
+      { id: request['id'], error: "#{request['path']}: #{e.message}" }
+    rescue StandardError => e
+      { id: (request['id'] if request.is_a?(Hash)), error: e.message.to_s }
     end
 
     def edit(request)
@@ -59,7 +60,7 @@ module Raindown
     end
 
     def nodes_changed?(project)
-      stamp = Dir.glob(File.join(project, Nodes::FOLDER, '**', '*')).to_h { [it, File.mtime(it)] }
+      stamp = Dir.glob(File.join(project, Nodes::FOLDER, '**', '*')).to_h { [it, File.lstat(it).mtime] }
       changed = @stamps.key?(project) && @stamps[project] != stamp
       @stamps[project] = stamp
       changed

data/lib/raindown/table/table.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'csv'
 require 'digest'
 require 'json'
 
 require_relative '../node'
 require_relative '../utils'
 require_relative 'markdown_table'
+require_relative 'table_file'
 require_relative 'table_formulas'
 require_relative 'written_table'
 
@@ -26,24 +26,31 @@ module Raindown
   # 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/
+    # 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.
+    # 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)
       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)
     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,21 +65,34 @@ 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, which has no comment yet when it's just been typed, below any alert saying why
+    # there was no file.
+    def create_file(path, lines)
+      rows = MarkdownTable.parse(lines.grep_v(COMMENT).grep_v(/\A>/))
+      rows = 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)
+      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
+      return markdown(TableFile.write(path, with_file_cells(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")
@@ -144,17 +164,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_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/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

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.2
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -248,6 +248,7 @@ files:
 - lib/raindown/page.rb
 - lib/raindown/pages.rb
 - lib/raindown/pre_renderer.rb
+- lib/raindown/problem.rb
 - lib/raindown/projects.rb
 - lib/raindown/rewriter.rb
 - lib/raindown/server.rb
@@ -255,6 +256,7 @@ files:
 - lib/raindown/stat.rb
 - lib/raindown/table/markdown_table.rb
 - lib/raindown/table/table.rb
+- lib/raindown/table/table_file.rb
 - lib/raindown/table/table_formatter.rb
 - lib/raindown/table/table_formulas.rb
 - lib/raindown/table/written_table.rb