raindown 0.10.0 → 0.12.0

data/lib/raindown/rewriter.rb

@@ -8,26 +8,27 @@ require_relative 'utils'
 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.
-  # Each rewriter responds to rewrite(content:, path:, bare:, execute:, metadata:) and returns the new content.
   module Rewriter
-    REWRITERS = [NodeInjector, EndpointRunner, TableFormatter].freeze
+    # 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
+      def changed?
+        content != original
+      end
+    end
 
     module_function
 
     def rewrite(content:, path:, bare: false, execute: false, metadata: NoMetadata)
-      REWRITERS.reduce(content) do |rewritten, rewriter|
-        rewriter.rewrite(content: rewritten, path:, bare:, execute:, metadata:)
-      end
+      injected = NodeInjector.rewrite(content:, path:, bare:, metadata:)
+      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)
     end
 
-    # Returns true when the file changed.
+    # Writes the file only when it changed.
     def update(path:, bare: false, execute: false, metadata: NoMetadata)
-      content = Utils.read_markdown(path)
-      rewritten = rewrite(content:, path:, bare:, execute:, metadata:)
-      return false if rewritten == content
-
-      File.write(path, rewritten)
-      true
+      rewrite(content: Utils.read_markdown(path), path:, bare:, execute:, metadata:).tap do |rewrite|
+        File.write(path, rewrite.content) if rewrite.changed?
+      end
     end
   end
 end

data/lib/raindown/server.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../version'
+require_relative 'editing'
+require_relative 'projects'
+require_relative 'workers/workers'
+
+module Raindown
+  # "raindown server" keeps Raindown loaded for editors, like the Obsidian plugin and the VS Code extension, so a render
+  # doesn't start Ruby again. Once it's ready, it says so, then answers a JSON request a line, in order:
+  #   {"ready": true, "version": "0.10.0"}
+  #   {"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.
+  # 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
+    def initialize(input: $stdin, output: $stdout)
+      @input = input
+      @output = output
+      @workers = Workers.new(root: Dir.pwd) { Editing }
+      @stamps = {}
+    end
+
+    def start
+      write(ready: true, version: VERSION)
+      @input.each_line { |line| write(answer(line)) }
+    ensure
+      @workers.stop
+    end
+
+    private
+
+    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}" }
+    end
+
+    def edit(request)
+      path = File.expand_path(request.fetch('path'))
+      options = { path:, bare: request['bare'] == true }
+      worker = worker_for(path)
+      return worker.call(:rewrite_markdown, request.fetch('markdown'), **options, execute: request['execute'] == true) if request['rewrite']
+
+      { output: worker.call(:render_markdown, request.fetch('markdown'), **options) }
+    end
+
+    # The project's worker, started again first when a file in its .raindown folder was added, changed or removed.
+    def worker_for(path)
+      project = Projects.root(path) || @workers.root
+      @workers.restart(project) if nodes_changed?(project)
+      @workers[project]
+    end
+
+    def nodes_changed?(project)
+      stamp = Dir.glob(File.join(project, Nodes::FOLDER, '**', '*')).to_h { [it, File.mtime(it)] }
+      changed = @stamps.key?(project) && @stamps[project] != stamp
+      @stamps[project] = stamp
+      changed
+    end
+
+    def write(message)
+      @output.puts(JSON.generate(message))
+      @output.flush
+    end
+  end
+end

data/lib/raindown/tui/blueprints/blueprints_view.rb

@@ -11,7 +11,7 @@ require_relative 'filter'
 
 module Raindown
   module TUI
-    # The blueprints from Claude Code's replies, in the project's .raindown/blueprints.md, newest first, then those in its
+    # The blueprints from Claude Code's replies, in the project's .raindown/data/blueprints.md, newest first, then those in its
     # code's comments, one at a time, of
     # those its Filter's keywords match, each traced to its code: the arrows move between the boxes drawn in one, or a
     # click on one, the code each box names shows below, Space or another click moving on to

data/lib/raindown/tui/feelings/feelings_log.rb

@@ -22,16 +22,16 @@ module Raindown
       end
     end
 
-    # The feelings everyone's sorted about the code as it is now, kept in .raindown/feelings.csv with the commit they were
+    # The feelings everyone's sorted about the code as it is now, kept in .raindown/data/feelings.csv with the commit they were
     # felt at, which a node can count, like the README's code debt. A feeling about code that's since changed, or gone, moves to
-    # .raindown/memories.csv, so the feelings stay few, and the history's kept.
+    # .raindown/data/memories.csv, so the feelings stay few, and the history's kept.
     class FeelingsLog
       TEMPERS = %w[frolic numb woe dread malice].freeze
       HEADER = %i[timestamp commit checksum location method temper note].freeze
       def initialize(root:)
         @root = root
-        @csv = File.join(root, '.raindown', 'feelings.csv')
-        @memories = File.join(root, '.raindown', 'memories.csv')
+        @csv = File.join(root, '.raindown', 'data', 'feelings.csv')
+        @memories = File.join(root, '.raindown', 'data', 'memories.csv')
       end
 
       # Adds the feeling, as the newest, in place of one about the method before, which moves to the memories if it was

data/lib/raindown/tui/project.rb

@@ -90,8 +90,9 @@ module Raindown
 
       def endpoint(path, lines, directive)
         snippet = CodeBlocks.endpoint(lines, directive.line).first&.dig(:body)
-        request = Curl.request(snippet.to_s, EndpointVariables.new(path:, content: lines.join))
-        Endpoint.new(project: root, path:, line: directive.line, **request.to_h) if request
+        variables = EndpointVariables.new(path:, content: lines.join)
+        request = Curl.request(snippet.to_s, variables)
+        Endpoint.new(project: root, path:, line: directive.line, method: request.method, url: variables.redact(request.url)) if request
       end
 
       def charts_in(path)

data/lib/raindown/watcher/file_watcher.rb

@@ -51,7 +51,9 @@ module Raindown
 
       # The files' metadata is loaded again each time, so new and renamed files are listed.
       def rewrite
-        Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path))
+        rewrite = Rewriter.update(path:, bare:, execute:, metadata: Pages.for(path))
+        rewrite.failures.each { warn "Endpoint check failed: #{it}" }
+        rewrite.changed?
       end
     end
   end

data/lib/raindown/watcher/project.rb

@@ -28,8 +28,9 @@ module Raindown
 
       # Writing back saves the file again, and that save changes nothing, so it ends there.
       def update(path)
-        changed = Rewriter.update(path:, bare: @bare, execute: @execute, metadata: Pages.for(path))
-        puts "[#{name}] Updated #{relative(path)}" if changed
+        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}" }
       rescue StandardError => e
         raise if ENV['RAINDOWN_DEBUG']
 

data/lib/raindown/wiki_links.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'code'
+require_relative 'front_matter'
+
+module Raindown
+  # Obsidian's links between notes, which render as Markdown links to the file they name, by its path in the project,
+  # like files: links, while the file keeps them as they are:
+  #   [[Reading list]]                   [Reading list](<notes/Reading list.md>)
+  #   [[Reading list|books]]             [books](<notes/Reading list.md>)
+  #   [[Reading list#To read]]           [Reading list > To read](<notes/Reading list.md#to-read>)
+  # A name matches a file's name, or the end of its path, like [[notes/Reading list]], without its extension and
+  # whatever its case. One that matches no file, and ones in code or front matter, are left as they are, as are
+  # embeds, like ![[photo.png]].
+  module WikiLinks
+    LINK = /(?<!!)\[\[([^\[\]|#\n]+)(?:#([^\[\]|\n]+))?(?:\|([^\[\]\n]+))?\]\]/
+
+    module_function
+
+    def to_markdown(markdown, metadata:)
+      return markdown unless markdown.include?('[[')
+
+      pages = metadata.list
+      links(markdown).reverse_each.with_object(markdown.b) do |link, bytes|
+        page = page_for(link[1], pages)
+        bytes[link.byteoffset(0)[0]...link.byteoffset(0)[1]] = markdown_link(link, page).b if page
+      end.force_encoding('UTF-8')
+    end
+
+    # The links in the Markdown, outside its code and front matter, as matches.
+    def links(markdown)
+      start = markdown.bytesize - FrontMatter.parse(markdown).last.bytesize
+      code = Code.ranges(markdown)
+      found = []
+
+      markdown.scan(LINK) do
+        link = ::Regexp.last_match
+        offset = link.byteoffset(0)[0]
+        found << link if offset >= start && code.none? { it.cover?(offset) }
+      end
+
+      found
+    end
+
+    # The page a name links to: one whose path without its extension is the name, or ends with it.
+    def page_for(name, pages)
+      name = name.strip.downcase.sub(/\.(?:md|rd|markdown|raindown)\z/, '')
+      stems = pages.to_h { [it, it.path.to_s.downcase.sub(%r{\.[^./]+\z}, '')] }
+
+      pages.find { stems[it] == name } || pages.find { stems[it].end_with?("/#{name}") }
+    end
+
+    def markdown_link(link, page)
+      name, heading, label = link.captures.map { it&.strip }
+      label ||= [name, heading].compact.join(' > ')
+      anchor = "##{anchor(heading)}" if heading
+
+      "[#{label.gsub(/[\[\]]/) { "\\#{it}" }}](<#{page.path}#{anchor}>)"
+    end
+
+    # A heading's id, the way Commonmarker makes it, like to-read for "To read".
+    def anchor(heading)
+      heading.downcase.gsub(/[^\p{Word}\- ]/, '').tr(' ', '-')
+    end
+  end
+end

data/lib/raindown.rb

@@ -17,6 +17,7 @@ require_relative 'raindown/pages'
 require_relative 'raindown/pre_renderer'
 require_relative 'raindown/utils'
 require_relative 'raindown/variables'
+require_relative 'raindown/wiki_links'
 
 module Raindown
   # Antlers evaluates any braces in the HTML, so braces in code are swapped for placeholders
@@ -83,6 +84,7 @@ module Raindown
   # The document's HTML from Commonmarker, after nodes and the template pass, with components as fragments.
   def html(markdown:, variables:, metadata: NoMetadata, bare: false)
     markdown = NodeBlocks.to_rendered(markdown.dup.force_encoding('UTF-8'), metadata:, bare:)
+    markdown = WikiLinks.to_markdown(markdown, metadata:)
     commonmark(PreRenderer.render(markdown, variables:, metadata:, bare:))
   end
 

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - maedi
@@ -121,6 +121,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: lowtype
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: plugs
   requirement: !ruby/object:Gem::Requirement
@@ -211,9 +225,13 @@ files:
 - lib/raindown/config.rb
 - lib/raindown/directives.rb
 - lib/raindown/document.rb
+- lib/raindown/editing.rb
 - lib/raindown/endpoint/curl.rb
+- lib/raindown/endpoint/curl_response.rb
+- lib/raindown/endpoint/endpoint_args.rb
 - lib/raindown/endpoint/endpoint_runner.rb
 - lib/raindown/endpoint/endpoint_variables.rb
+- lib/raindown/endpoint/schema_block.rb
 - lib/raindown/files.rb
 - lib/raindown/fragments.rb
 - lib/raindown/front_matter.rb
@@ -221,6 +239,7 @@ files:
 - lib/raindown/heading_ids.rb
 - lib/raindown/js/host.mjs
 - lib/raindown/js/js_nodes.rb
+- lib/raindown/markdown_nodes.rb
 - lib/raindown/node.rb
 - lib/raindown/node_blocks.rb
 - lib/raindown/node_injector.rb
@@ -230,6 +249,7 @@ files:
 - lib/raindown/pre_renderer.rb
 - lib/raindown/projects.rb
 - lib/raindown/rewriter.rb
+- lib/raindown/server.rb
 - lib/raindown/stat.rb
 - lib/raindown/table_formatter.rb
 - lib/raindown/toc.rb
@@ -305,6 +325,7 @@ files:
 - lib/raindown/watcher/file_watcher.rb
 - lib/raindown/watcher/project.rb
 - lib/raindown/watcher/supervisor.rb
+- lib/raindown/wiki_links.rb
 - lib/raindown/workers/worker.rb
 - lib/raindown/workers/workers.rb
 - lib/version.rb