raindown 0.5.0 → 0.6.0

data/lib/raindown/tui/workers/worker.rb

@@ -0,0 +1,124 @@
+# 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.
+    # 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.
+    class Worker
+      class Error < StandardError; end
+
+      class << self
+        attr_writer :fork
+
+        def fork?
+          @fork.nil? ? Process.respond_to?(:fork) : @fork
+        end
+
+        # Every worker's pipes, which a new worker closes the others of, since a worker holding another's pipe open
+        # would keep that worker from seeing it close.
+        def pipes
+          @pipes ||= []
+        end
+      end
+
+      attr_reader :root
+
+      def initialize(root:, fork: self.class.fork?)
+        @root = root
+        @fork = fork
+      end
+
+      # The Project's 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
+
+        start unless alive?
+        write(@requests, [name, args, options])
+        status, value = read(@answers) || raise(Error, "The worker for #{File.basename(root)} stopped")
+        status == :ok ? value : raise(Error, value)
+      end
+
+      def stop
+        [@requests, @answers].compact.each { it.close unless it.closed? }
+        return unless @pid
+
+        Process.kill('TERM', @pid)
+        Process.wait(@pid)
+      rescue Errno::ECHILD, Errno::ESRCH
+        nil
+      ensure
+        @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
+
+      def start
+        stop
+        requests, @requests = IO.pipe
+        @answers, answers = IO.pipe
+        self.class.pipes.reject!(&:closed?)
+        self.class.pipes.push(@requests, @answers)
+        @pid = fork do
+          self.class.pipes.each { it.close unless it.closed? }
+          serve(requests, answers)
+        end
+        requests.close
+        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.
+      def serve(requests, answers)
+        trap('INT', 'IGNORE')
+        $stdout.reopen(File::NULL)
+        $stderr.reopen(File::NULL)
+        project = Project.new(root:)
+
+        while (request = read(requests))
+          write(answers, answer(project, *request))
+        end
+      ensure
+        exit!(0)
+      end
+
+      def answer(project, name, args, options)
+        [:ok, project.public_send(name, *args, **options)]
+      rescue StandardError, ScriptError => e
+        [:error, e.message]
+      end
+
+      def alive?
+        @pid && Process.waitpid(@pid, Process::WNOHANG).nil?
+      rescue Errno::ECHILD
+        false
+      end
+
+      # A message is its length, then its Marshal data.
+      def write(io, message)
+        data = Marshal.dump(message)
+        io.write([data.bytesize].pack('N'), data)
+        io.flush
+      rescue Errno::EPIPE, IOError
+        raise Error, "The worker for #{File.basename(root)} stopped"
+      end
+
+      def read(io)
+        length = io.read(4)&.unpack1('N')
+        Marshal.load(io.read(length)) if length # rubocop:disable Security/MarshalLoad -- from this process's own fork
+      rescue IOError
+        nil
+      end
+    end
+  end
+end

data/lib/raindown/tui/workers/workers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../../projects'
+require_relative 'worker'
+
+module Raindown
+  module TUI
+    # A Worker for each project in the terminal UI's folder: the folder's own, and every project inside it.
+    # A file's requests go to the worker of the project it's in, the nearest one above it, even when it's new.
+    # Workers start when they're first asked something.
+    class Workers
+      attr_reader :root, :roots
+
+      def initialize(root:, fork: Worker.fork?)
+        @root = root
+        @fork = fork
+        @workers = {}
+        find_roots
+      end
+
+      def for(path)
+        worker(Projects.root(path) || root)
+      end
+
+      # A worker for each project, as they were found when the workers last started.
+      def each(&)
+        roots.map { worker(it) }.each(&)
+      end
+
+      # Stops the workers, so the next requests start them again, loading their projects' nodes again,
+      # and finds the projects again, like ones added since.
+      def restart
+        stop
+        @workers.clear
+        find_roots
+      end
+
+      def stop
+        @workers.each_value(&:stop)
+      end
+
+      private
+
+      def worker(project)
+        @workers[project] ||= Worker.new(root: project, fork: @fork)
+      end
+
+      def find_roots
+        @roots = [root, *Projects.roots(root)].uniq.sort
+      end
+    end
+  end
+end

data/lib/raindown/tui.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'nodes'
 require_relative 'projects'
-require_relative 'tui/navigator'
+require_relative 'tui/navigator/navigator'
 
 module Raindown
   # The terminal UI, started with "raindown tui": a project's Markdown files beside the open file's outline,
@@ -13,15 +12,19 @@ module Raindown
 
     # PATH is a file to open, or a directory. Its project is the one it's in, or else the directory itself.
     def start(path)
-      require_relative 'tui/screen'
+      require_relative 'tui/terminal/screen'
       # Without a terminal, curses' own error is "Error opening terminal: unknown".
       abort('raindown tui needs a terminal') unless $stdin.tty? && $stdout.tty?
 
       path = File.expand_path(path)
       root = Projects.root(path) || (File.directory?(path) ? path : File.dirname(path))
-      Nodes.load(File.join(root, Nodes::FOLDER))
+      # The projects inside it are shown too. Each loads its own nodes in its worker's process, like when watching,
+      # so two projects' nodes of the same name stay apart.
+      workers = Workers.new(root:)
 
-      Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)))).run
+      Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)), workers:)).run
+    ensure
+      workers&.stop
     end
   end
 end

data/lib/raindown.rb

@@ -47,6 +47,8 @@ module Raindown
   # Directives like "toc:" export to HTML as bold or comments depending on hide_directives config.
   # 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)
+    bare ||= BareDirectives.front_matter?(markdown)
+
     highlighting(highlight_code) do
       Fragments.collect do
         # Components' HTML goes back in, then their headings get unique ids, before nodes like the TOC see it.

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-10-26 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -216,16 +216,39 @@ files:
 - lib/raindown/table_formatter.rb
 - lib/raindown/toc.rb
 - lib/raindown/tui.rb
-- lib/raindown/tui/commands.rb
+- lib/raindown/tui/card.rb
+- lib/raindown/tui/endpoint.rb
+- lib/raindown/tui/endpoints.rb
+- lib/raindown/tui/events.rb
 - lib/raindown/tui/file_tree.rb
-- lib/raindown/tui/input.rb
 - lib/raindown/tui/layout.rb
-- lib/raindown/tui/navigator.rb
-- lib/raindown/tui/outline.rb
-- lib/raindown/tui/pane.rb
+- lib/raindown/tui/menu_overlay.rb
+- lib/raindown/tui/navigator/commands.rb
+- lib/raindown/tui/navigator/focus.rb
+- lib/raindown/tui/navigator/navigator.rb
+- lib/raindown/tui/navigator/project_menu.rb
+- lib/raindown/tui/navigator/views.rb
+- lib/raindown/tui/renderers/dashboard_renderer.rb
+- lib/raindown/tui/renderers/endpoint_renderer.rb
+- lib/raindown/tui/renderers/list_renderer.rb
+- lib/raindown/tui/renderers/outline_renderer.rb
+- lib/raindown/tui/renderers/renderer.rb
 - lib/raindown/tui/row.rb
-- lib/raindown/tui/screen.rb
-- lib/raindown/tui/styles.rb
+- lib/raindown/tui/rows.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/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/version.rb

data/lib/raindown/tui/commands.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../actions'
-
-module Raindown
-  module TUI
-    # What a Navigator does to the open file: run an endpoint, open the editor, write back and read it again.
-    # Each sets the status, so the Screen shows how it went, and returns what the Screen should do next, if anything.
-    module Commands
-      private
-
-      def execute
-        directive = selected(:outline)&.target if @focus == :outline
-        return error('Select an endpoint to run') unless directive.is_a?(Document::Directive) && directive.endpoint?
-
-        [:wait, "Running the endpoint on line #{directive.line}...", -> { run_endpoint(directive) }]
-      end
-
-      def run_endpoint(directive)
-        changed = Actions.execute(path, directive)
-        @outline.read
-        info(changed ? "Ran the endpoint on line #{directive.line}" : 'The response is the same')
-      rescue StandardError => e
-        error(e.message)
-      end
-
-      # In the files pane, the selected file opens at its top, and in the outline, the open file at the selected line.
-      def edit
-        row = selected
-        show(row.target) if @focus == :files && row&.kind == :file
-        return error('Open a file to edit') unless path
-
-        line = @focus == :outline && row ? row.line : 1
-        [:run, Actions.edit_command(path, line:)]
-      end
-
-      def write_back
-        return error('Open a file to write back') unless path
-
-        changed = Actions.write_back(path)
-        @outline.read
-        info(changed ? "Updated #{relative(path)}" : "#{relative(path)} is up to date")
-      rescue StandardError => e
-        error(e.message)
-      end
-
-      def reload
-        @files.load
-        @outline&.read if path && File.exist?(path)
-        info('Reloaded')
-      end
-
-      # Reads the file again when it's changed, like when it's saved in an editor or a watcher writes back to it.
-      def refresh
-        @outline.read if @outline&.changed?
-        nil
-      end
-
-      def info(message)
-        @status = [:info, message]
-        nil
-      end
-
-      def error(message)
-        @status = [:error, message]
-        nil
-      end
-    end
-  end
-end

data/lib/raindown/tui/navigator.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'file_tree'
-require_relative 'commands'
-require_relative 'outline'
-require_relative 'pane'
-
-module Raindown
-  module TUI
-    # What the terminal UI shows and does, in plain Ruby, with no terminal: a FileTree of the project's Markdown files,
-    # beside the open file's Outline. The Screen draws it and sends it events, like :down or
-    # [:press, :outline, 3, :execute], and handle returns what the Screen should do next:
-    #   nil                     draw again
-    #   :quit                   stop
-    #   [:run, command]         leave the screen to run a command, like the editor, then call ran
-    #   [:wait, message, task]  show the message while the task runs, like an endpoint's request
-    class Navigator
-      include Commands
-
-      # Keys of the events that move the cursor or the focus, and those that act on what's selected.
-      MOVES = { up: -1, down: 1 }.freeze
-      PANES = { tab: nil, left: :files, right: :outline }.freeze
-      ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
-
-      attr_reader :focus, :status
-
-      def initialize(root:, path: nil)
-        @files = FileTree.new(root:)
-        @focus = :files
-        @panes = { files: Pane.new { @files.rows }, outline: Pane.new { @outline ? @outline.rows : [] } }
-        @status = [:info, 'Tab switches panes, Enter opens and folds, q quits']
-        first = @files.rows.find { it.kind == :file }&.target
-        show(path || first) if path || first
-      end
-
-      def handle(event)
-        name, *args = event
-        return :quit if name == :quit
-        return move(MOVES[name]) if MOVES.key?(name)
-        return switch(PANES[name] || other_pane) if PANES.key?(name)
-        return select(*args) if name == :select
-        return press(*args) if name == :press
-        return activate(name) if %i[enter toggle].include?(name)
-
-        send(ACTIONS[name]) if ACTIONS.key?(name)
-      end
-
-      # After the editor closes, the file is written back, like a save while it's watched, and read again.
-      def ran
-        write_back
-      end
-
-      def root = @files.root
-      def path = @outline&.path
-      def relative(path) = @files.relative(path)
-
-      def rows(pane) = @panes[pane].rows
-      def cursor(pane) = @panes[pane].cursor
-      def visible(pane, height) = @panes[pane].visible(height)
-
-      private
-
-      def show(path)
-        @outline = Outline.new(File.expand_path(path))
-        @panes[:outline].reset
-      end
-
-      def other_pane
-        @focus == :files ? :outline : :files
-      end
-
-      def move(by)
-        @panes[@focus].move(by)
-        nil
-      end
-
-      def switch(pane)
-        @focus = pane
-        nil
-      end
-
-      def select(pane, index)
-        @focus = pane
-        @panes[pane].cursor = index
-        nil
-      end
-
-      def press(pane, index, event)
-        select(pane, index)
-        handle(event)
-      end
-
-      def selected(pane = @focus)
-        @panes[pane].selected
-      end
-
-      # Enter opens what's selected, or folds it, and Space only folds.
-      # A line of output, or a directive without any, opens in the editor.
-      def activate(name)
-        row = selected
-        return edit if name == :enter && editable?(row)
-
-        case row&.kind
-        when :folder then @files.toggle(row.target)
-        when :file then open_file(row.target) if name == :enter
-        when :heading then @outline.fold(row.target)
-        when :directive then @outline.expand(row.target) if row.target.output
-        end
-        nil
-      end
-
-      def editable?(row)
-        row&.kind == :output || (row&.kind == :directive && !row.target.output)
-      end
-
-      def open_file(path)
-        show(path)
-        @focus = :outline
-        info("Opened #{relative(path)}")
-      end
-    end
-  end
-end

data/lib/raindown/tui/styles.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'curses'
-
-module Raindown
-  module TUI
-    # The curses attributes of a Layout's styles, in colour on the terminal's own background when it has colours.
-    module Styles
-      COLORS = { directive: Curses::COLOR_CYAN, button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED,
-                 folder: Curses::COLOR_BLUE }.freeze
-
-      module_function
-
-      # Sets up the colours, once the screen has started, and returns the attribute of each style.
-      def start
-        colors = Curses.has_colors?
-        start_colors if colors
-        color = ->(name) { colors ? Curses.color_pair(COLORS.keys.index(name) + 1) : Curses::A_NORMAL }
-
-        {
-          title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, cursor: Curses::A_UNDERLINE,
-          heading: Curses::A_BOLD, directive: color[:directive], output: Curses::A_DIM,
-          error: color[:error] | Curses::A_BOLD, button: color[:button] | Curses::A_BOLD,
-          selected_button: color[:button] | Curses::A_REVERSE, folder: color[:folder] | Curses::A_BOLD,
-          key: Curses::A_REVERSE, border: Curses::A_DIM
-        }
-      end
-
-      def start_colors
-        Curses.start_color
-        Curses.use_default_colors
-        COLORS.each_value.with_index(1) { |color, pair| Curses.init_pair(pair, color, -1) }
-      end
-    end
-  end
-end