raindown 0.7.0 → 0.8.0

data/lib/raindown/watcher/project.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../../raindown'
+require_relative '../rewriter'
+
+module Raindown
+  module Watcher
+    # Writes back to one project's Markdown files as they're saved, like its TOCs, tables and endpoint responses,
+    # with the project's own nodes, in its Workers::Worker. Each line it shows starts with the project's name.
+    class Project
+      attr_reader :root, :name
+
+      def initialize(root:, name: File.basename(root), bare: false, execute: false)
+        @root = root
+        @name = name
+        @bare = bare
+        @execute = execute
+      end
+
+      # Loads the project's nodes from its .raindown folder.
+      def start
+        Nodes.load(File.join(root, Nodes::FOLDER))
+      rescue StandardError, ScriptError => e
+        raise if ENV['RAINDOWN_DEBUG']
+
+        warn "[#{name}] raindown: #{Nodes::FOLDER}: #{e.message}"
+      end
+
+      # 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
+      rescue StandardError => e
+        raise if ENV['RAINDOWN_DEBUG']
+
+        # An error in the file is shown rather than stopping the watcher, so it can be fixed and saved again.
+        warn "[#{name}] raindown: #{relative(path)}: #{e.message}"
+      end
+
+      private
+
+      def relative(path)
+        File.expand_path(path).delete_prefix(File.join(root, ''))
+      end
+    end
+  end
+end

data/lib/raindown/watcher/supervisor.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative '../projects'
+require_relative '../workers/workers'
+require_relative 'changes'
+require_relative 'project'
+
+module Raindown
+  module Watcher
+    # Watches every Raindown project in a directory, like ~/dev, and writes back to each Markdown file as it's saved.
+    #
+    # Each project's nodes load in a process of its own, forked once the shared code has loaded, so starting a project
+    # costs almost nothing and two projects can have nodes of the same name. One listener watches the directory and
+    # sends each changed file to its project's process. Without fork, as on Windows, the projects share this process.
+    class Supervisor
+      attr_reader :directory, :workers
+
+      def initialize(directory:, bare: false, execute: false)
+        @directory = File.expand_path(directory)
+        @workers = Workers.new(root: @directory, fork: fork?, quiet: false) do |root|
+          Project.new(root:, name: name(root), bare:, execute:).tap(&:start)
+        end
+        @queues = {}
+      end
+
+      def start
+        $stdout.sync = true
+        preload
+
+        projects = Projects.roots(directory).each { workers[it].start }
+        puts "Watching #{projects.size} #{projects.size == 1 ? 'project' : 'projects'} in #{directory} for changes..."
+
+        trap_interrupt
+        Watcher.listen(directory) { handle(it) }.start
+        sleep
+      ensure
+        stop
+      end
+
+      # Sends each saved file to its project, starting a worker for a new project, or restarting one when its nodes
+      # change. With fork, each project takes its changes in order in a thread of its own, so a slow write-back, like an
+      # 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|
+          next unless change.nodes? || change.saved?
+          next take(change) unless fork?
+
+          queue(change.root) << change
+        end
+      end
+
+      def stop
+        @queues.each_value(&:close)
+        workers.stop
+      end
+
+      private
+
+      # The project's changes still to take, by the thread that takes them, until the queue's closed.
+      def queue(root)
+        @queues[root] ||= Thread::Queue.new.tap do |queue|
+          Thread.new { while (change = queue.pop) do take(change) end }
+        end
+      end
+
+      # An error, like a worker stopping partway from a crash, is shown, and the project takes its next change, its
+      # worker starting again.
+      def take(change)
+        return restart(change.root) if change.nodes?
+
+        workers[change.root].call(:update, change.path)
+      rescue StandardError => e
+        warn "[#{name(change.root)}] raindown: #{e.message}"
+      end
+
+      # Without fork the projects share this process, where nodes can't be unloaded.
+      def restart(root)
+        return warn("[#{name(root)}] Restart raindown to load the node changes") unless fork?
+        return unless workers.restart(root)
+
+        puts "[#{name(root)}] Reloading nodes"
+        workers[root].start
+      end
+
+      # A project in the directory is named by its path from there, and the project the directory is in by its folder.
+      def name(root)
+        return File.basename(root) unless root.start_with?(File.join(directory, ''))
+
+        root.delete_prefix(File.join(directory, ''))
+      end
+
+      # Loaded before forking, so every project's process shares them instead of loading its own.
+      def preload
+        return unless fork?
+
+        require 'lownode'
+        require 'dirload'
+      end
+
+      def fork?
+        Process.respond_to?(:fork)
+      end
+
+      # Ctrl+C reaches every process in the terminal, so the workers stop with the watcher.
+      def trap_interrupt
+        trap('INT') { exit }
+      end
+    end
+  end
+end

data/lib/raindown/{tui/workers → workers}/worker.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-require_relative 'project'
-
 module Raindown
-  module TUI
-    # A Project in a process of its own, forked so it loads the project's nodes apart from other projects', like watching.
+  class Workers
+    # What answers a project's requests, made by the block, like the terminal UI's Project, or a Watcher::Project when
+    # watching, in a process of its own, forked so it loads the project's nodes apart from other projects'.
     # Requests and answers go through two pipes, as Marshal data, one at a time. Without fork, like on Windows,
-    # or with fork off, like in specs, the Project answers in this process instead.
-    # The process ends with exit!, since it's forked mid-call, so the terminal UI's ensure doesn't run in it.
+    # or with fork off, like in specs, it answers in this process instead. A quiet worker writes nothing, as the terminal
+    # UI's screen is its own. The process ends with exit!, since it's forked mid-call, so the parent's ensure doesn't run.
     class Worker
       class Error < StandardError; end
 
@@ -27,12 +26,14 @@ module Raindown
 
       attr_reader :root
 
-      def initialize(root:, fork: self.class.fork?)
+      def initialize(root:, fork: self.class.fork?, quiet: true, &answering)
         @root = root
         @fork = fork
+        @quiet = quiet
+        @answering = answering
       end
 
-      # The Project's answer, or a Worker::Error with its error's message. A worker that stopped starts again.
+      # The answer, or a Worker::Error with its error's message. A worker that stopped starts again.
       def call(name, *args, **options)
         return local(name, args, options) unless @fork
 
@@ -54,21 +55,12 @@ module Raindown
         @pid = nil
       end
 
-      private
-
-      def local(name, args, options)
-        @project ||= Project.new(root:)
-        @project.public_send(name, *args, **options)
-      rescue StandardError => e
-        raise Error, e.message
-      end
-
+      # Starts the worker's process, or makes what answers in this one, so it's ready before the first request.
       def start
+        return @answerer ||= @answering.call unless @fork
+
         stop
-        requests, @requests = IO.pipe
-        @answers, answers = IO.pipe
-        self.class.pipes.reject!(&:closed?)
-        self.class.pipes.push(@requests, @answers)
+        requests, answers = open_pipes
         @pid = fork do
           self.class.pipes.each { it.close unless it.closed? }
           serve(requests, answers)
@@ -77,23 +69,39 @@ module Raindown
         answers.close
       end
 
-      # Answers until the terminal UI closes its end. The screen is the terminal UI's, so nothing is written to it,
-      # and Ctrl+C, which reaches every process in the terminal, is the terminal UI's to handle.
+      private
+
+      # The worker's ends of the pipes, while this process keeps the others.
+      def open_pipes
+        requests, @requests = IO.pipe
+        @answers, answers = IO.pipe
+        self.class.pipes.reject!(&:closed?)
+        self.class.pipes.push(@requests, @answers)
+        [requests, answers]
+      end
+
+      def local(name, args, options)
+        start.public_send(name, *args, **options)
+      rescue StandardError => e
+        raise Error, e.message
+      end
+
+      # Answers until the parent closes its end. Ctrl+C, which reaches every process in the terminal, is the parent's to
+      # handle, stopping its workers.
       def serve(requests, answers)
         trap('INT', 'IGNORE')
-        $stdout.reopen(File::NULL)
-        $stderr.reopen(File::NULL)
-        project = Project.new(root:)
+        [$stdout, $stderr].each { it.reopen(File::NULL) } if @quiet
+        answerer = @answering.call
 
         while (request = read(requests))
-          write(answers, answer(project, *request))
+          write(answers, answer(answerer, *request))
         end
       ensure
         exit!(0)
       end
 
-      def answer(project, name, args, options)
-        [:ok, project.public_send(name, *args, **options)]
+      def answer(answerer, name, args, options)
+        [:ok, answerer.public_send(name, *args, **options)]
       rescue StandardError, ScriptError => e
         [:error, e.message]
       end

data/lib/raindown/workers/workers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../projects'
+require_relative 'worker'
+
+module Raindown
+  # A Worker for each project in a folder: the folder's own, and every project inside it, each answering with what the
+  # block makes from its root, like the terminal UI's Project. A file's requests go to the worker of the project it's in,
+  # the nearest one above it, even when it's new, or else the folder's. Workers start when they're first asked something.
+  class Workers
+    attr_reader :root
+
+    def initialize(root:, fork: Worker.fork?, quiet: true, &answering)
+      @root = root
+      @fork = fork
+      @quiet = quiet
+      @answering = answering
+      @workers = {}
+    end
+
+    def for(path) = self[Projects.root(path) || root]
+
+    def [](project)
+      @workers[project] ||= Worker.new(root: project, fork: @fork, quiet: @quiet) { @answering.call(project) }
+    end
+
+    # The folder's project and those inside it, found when they're first asked for, and again after a restart.
+    def roots = @roots ||= [root, *Projects.roots(root)].uniq.sort
+
+    # A worker for each project, as they were found when the workers last started.
+    def each(&)
+      roots.map { self[it] }.each(&)
+    end
+
+    # The workers asked something, by their project's root.
+    def started = @workers.dup
+
+    # Stops the project's worker, so its next request starts it again, loading its nodes again, and returns whether it
+    # had started. Without a project, they all stop, and the projects are found again, like ones added since.
+    def restart(project = nil)
+      return restart_project(project) if project
+
+      stop
+      @roots = nil
+    end
+
+    # Stops the workers, so the next requests start them again.
+    def stop
+      @workers.each_value(&:stop)
+      @workers.clear
+    end
+
+    private
+
+    def restart_project(project)
+      worker = @workers.delete(project)
+      return false unless worker
+
+      worker.stop
+      true
+    end
+  end
+end

data/lib/raindown.rb

@@ -37,16 +37,16 @@ module Raindown
 
   module_function
 
-  # Directives show in bold and code is highlighted, unless the file's project changes them in .raindown/config.yml.
+  # Code is highlighted, unless the file's project changes it in .raindown/config.yml.
   def render_file(path:, metadata: NoMetadata, bare: false, **options)
     options = Config.render_options(path).merge(options)
     render(markdown: File.read(path, encoding: Encoding::UTF_8), metadata:, bare: bare || BareDirectives.file?(path), **options)
   end
 
   # Front matter keys are variables, like {title} or <{ title }>.
-  # Directives like "toc:" export to HTML as bold or comments depending on hide_directives config.
+  # Bare directives like "toc:" show in bold in the HTML, and the rest stay hidden, as comments.
   # Code blocks are highlighted, unless highlight_code is false for a site that highlights code in the browser.
-  def render(markdown:, metadata: NoMetadata, bare: false, hide_directives: false, highlight_code: true)
+  def render(markdown:, metadata: NoMetadata, bare: false, highlight_code: true)
     bare ||= BareDirectives.front_matter?(markdown)
 
     highlighting(highlight_code) do
@@ -55,7 +55,7 @@ module Raindown
         html = assembled(markdown:, metadata:, bare:)
         html = Nodes.render_placeholders(html, document: markdown, metadata:, bare:, html:)
 
-        Directives.render("#{html.chomp}\n", hide: hide_directives)
+        Directives.render("#{html.chomp}\n")
       end
     end
   end

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-10-28 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -197,6 +197,7 @@ files:
 - lib/raindown.rb
 - lib/raindown/actions.rb
 - lib/raindown/bare_directives.rb
+- lib/raindown/blueprints.rb
 - lib/raindown/chart/bars.rb
 - lib/raindown/chart/chart.rb
 - lib/raindown/chart/columns.rb
@@ -223,41 +224,56 @@ files:
 - lib/raindown/page.rb
 - lib/raindown/pages.rb
 - lib/raindown/pre_renderer.rb
-- lib/raindown/project_worker.rb
 - lib/raindown/projects.rb
 - lib/raindown/rewriter.rb
 - lib/raindown/stat.rb
-- lib/raindown/supervisor.rb
 - lib/raindown/table_formatter.rb
 - lib/raindown/toc.rb
 - lib/raindown/tui.rb
+- lib/raindown/tui/blueprints/blueprints_renderer.rb
+- lib/raindown/tui/blueprints/blueprints_view.rb
+- lib/raindown/tui/blueprints/canvas.rb
+- lib/raindown/tui/blueprints/code_comments.rb
+- lib/raindown/tui/blueprints/filter.rb
+- lib/raindown/tui/blueprints/traced_code.rb
+- lib/raindown/tui/blueprints/tracing.rb
 - lib/raindown/tui/card.rb
+- lib/raindown/tui/code_box.rb
 - lib/raindown/tui/endpoint.rb
 - lib/raindown/tui/endpoints.rb
 - lib/raindown/tui/events.rb
 - lib/raindown/tui/feelings/batch.rb
 - lib/raindown/tui/feelings/bins.rb
-- lib/raindown/tui/feelings/celebration.rb
-- lib/raindown/tui/feelings/code_box.rb
+- lib/raindown/tui/feelings/celebration/celebration.rb
+- lib/raindown/tui/feelings/celebration/fireworks.rb
+- lib/raindown/tui/feelings/celebration/rain.rb
+- lib/raindown/tui/feelings/celebration/scene.rb
+- lib/raindown/tui/feelings/cell_moves.rb
 - lib/raindown/tui/feelings/code_methods.rb
+- lib/raindown/tui/feelings/feelings_code_box.rb
 - lib/raindown/tui/feelings/feelings_log.rb
 - lib/raindown/tui/feelings/feelings_renderer.rb
 - lib/raindown/tui/feelings/feelings_view.rb
-- lib/raindown/tui/feelings/fireworks.rb
-- lib/raindown/tui/feelings/rain.rb
-- lib/raindown/tui/feelings/scene.rb
-- lib/raindown/tui/feelings/waffle.rb
+- lib/raindown/tui/feelings/magnifier.rb
+- lib/raindown/tui/feelings/motion.rb
+- lib/raindown/tui/feelings/waffle/baked_waffle.rb
+- lib/raindown/tui/feelings/waffle/balloons.rb
+- lib/raindown/tui/feelings/waffle/confetti.rb
+- lib/raindown/tui/feelings/waffle/sparkles.rb
+- lib/raindown/tui/feelings/waffle/waffle.rb
 - lib/raindown/tui/feelings/weekly_batch.rb
 - lib/raindown/tui/file_tree.rb
 - lib/raindown/tui/highlighter.rb
 - lib/raindown/tui/layout.rb
-- lib/raindown/tui/menu_overlay.rb
 - lib/raindown/tui/navigator/commands.rb
 - lib/raindown/tui/navigator/focus.rb
+- lib/raindown/tui/navigator/mouse.rb
 - lib/raindown/tui/navigator/navigator.rb
 - lib/raindown/tui/navigator/project_menu.rb
-- lib/raindown/tui/navigator/search.rb
+- lib/raindown/tui/navigator/teleport.rb
 - lib/raindown/tui/navigator/views.rb
+- lib/raindown/tui/project.rb
+- lib/raindown/tui/project_box.rb
 - lib/raindown/tui/renderers/dashboard_renderer.rb
 - lib/raindown/tui/renderers/endpoint_renderer.rb
 - lib/raindown/tui/renderers/list_renderer.rb
@@ -265,23 +281,27 @@ files:
 - lib/raindown/tui/renderers/renderer.rb
 - lib/raindown/tui/row.rb
 - lib/raindown/tui/rows.rb
-- lib/raindown/tui/search_overlay.rb
+- lib/raindown/tui/saves.rb
+- lib/raindown/tui/search_box.rb
 - lib/raindown/tui/terminal/input.rb
 - lib/raindown/tui/terminal/ncurses_shim.rb
 - lib/raindown/tui/terminal/quiet.rb
 - lib/raindown/tui/terminal/screen.rb
 - lib/raindown/tui/terminal/styles.rb
+- lib/raindown/tui/terminal/terminal_title.rb
 - lib/raindown/tui/text.rb
 - lib/raindown/tui/title.rb
 - lib/raindown/tui/views/dashboard_view.rb
 - lib/raindown/tui/views/endpoint_view.rb
 - lib/raindown/tui/views/list_view.rb
 - lib/raindown/tui/views/outline_view.rb
-- lib/raindown/tui/workers/project.rb
-- lib/raindown/tui/workers/worker.rb
-- lib/raindown/tui/workers/workers.rb
 - lib/raindown/variables.rb
-- lib/raindown/watcher.rb
+- lib/raindown/watcher/changes.rb
+- lib/raindown/watcher/file_watcher.rb
+- lib/raindown/watcher/project.rb
+- lib/raindown/watcher/supervisor.rb
+- lib/raindown/workers/worker.rb
+- lib/raindown/workers/workers.rb
 - lib/version.rb
 homepage: https://github.com/raindeer-rb/raindown
 licenses: []

data/lib/raindown/project_worker.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../raindown'
-require_relative 'rewriter'
-
-module Raindown
-  # Writes back to one project's Markdown files as they're saved, like its TOCs, tables and endpoint responses,
-  # with the project's own nodes. Each line it shows starts with the project's name.
-  class ProjectWorker
-    attr_reader :root, :name
-
-    def initialize(root:, name: File.basename(root), bare: false, execute: false)
-      @root = root
-      @name = name
-      @bare = bare
-      @execute = execute
-    end
-
-    # Loads the project's nodes from its .raindown folder.
-    def start
-      Nodes.load(File.join(root, Nodes::FOLDER))
-    rescue StandardError, ScriptError => e
-      raise if ENV['RAINDOWN_DEBUG']
-
-      warn "[#{name}] raindown: #{Nodes::FOLDER}: #{e.message}"
-    end
-
-    # 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
-    rescue StandardError => e
-      raise if ENV['RAINDOWN_DEBUG']
-
-      # An error in the file is shown rather than stopping the watcher, so it can be fixed and saved again.
-      warn "[#{name}] raindown: #{relative(path)}: #{e.message}"
-    end
-
-    # Workers in this process have nothing to stop, unlike a ForkedWorker's process.
-    def stop; end
-
-    private
-
-    def relative(path)
-      File.expand_path(path).delete_prefix(File.join(root, ''))
-    end
-  end
-end