raindown 0.5.1 → 0.6.0

data/lib/raindown/tui/{pane.rb → views/list_view.rb}

@@ -2,8 +2,8 @@
 
 module Raindown
   module TUI
-    # A pane's cursor and how far it's scrolled, over rows that can change between draws, like when a folder folds.
-    class Pane
+    # Rows with a cursor, and how far they're scrolled, which can change between draws, like when a folder folds.
+    class ListView
       attr_writer :cursor
 
       def initialize(&rows)
@@ -12,6 +12,8 @@ module Raindown
         @offset = 0
       end
 
+      def renderer = ListRenderer
+
       def rows = @rows.call
       def selected = rows[cursor]
 
@@ -20,13 +22,12 @@ module Raindown
         @cursor.clamp(0, [rows.length - 1, 0].max)
       end
 
+      # Moves past rows that can't be selected, like separators, and stays at the first or last row rather than moving off them.
       def move(by)
-        @cursor = (cursor + by).clamp(0, [rows.length - 1, 0].max)
-      end
-
-      def reset
-        @cursor = 0
-        @offset = 0
+        rows = self.rows
+        index = cursor + by
+        index += by while index.between?(0, rows.length - 1) && !rows[index].selectable?
+        @cursor = index if index.between?(0, rows.length - 1)
       end
 
       # The rows that fit in the height, scrolled so the cursor's row is one of them, and the first one's index.

data/lib/raindown/tui/{outline.rb → views/outline_view.rb}

@@ -1,30 +1,41 @@
 # frozen_string_literal: true
 
-require_relative '../document'
-require_relative 'row'
+require_relative '../../document'
+require_relative '../events'
+require_relative 'list_view'
+require_relative '../row'
+require_relative '../workers/worker'
 
 module Raindown
   module TUI
-    # The outline pane: a file's headings and directives, read from its Document. Headings fold the section below them,
-    # and a directive's output, the lines Raindown wrote back, expands below it. Both start folded away.
-    class Outline
+    # The outline: a file's headings and directives, read by its project's Worker. Headings fold the section below them,
+    # and a directive's body expands below it, like the lines a node wrote back or an endpoint's request and response.
+    # Both start folded away. It's read when it's opened, and it's a ListView, with its own cursor.
+    class OutlineView < ListView
       attr_reader :path, :error
 
-      def initialize(path)
+      def initialize(path, workers:)
+        super()
         @path = path
+        @workers = workers
         @folded = Set.new
         @expanded = Set.new
-        read
       end
 
+      def renderer = OutlineRenderer
+      def target = path
+      def next_step?(_key) = false
+      def status(navigator) = [:info, "Opened #{navigator.relative(path)}"]
+
       # Reads the file again, keeping what's folded.
-      def read
+      def load
         @mtime = File.mtime(path)
-        @document = Document.read(path)
-        @lines = File.readlines(path, chomp: true)
-        @document.directives # Finds an error in the file, like a missing end tag, now rather than while drawing.
+        outline = @workers.for(path).call(:outline, path)
+        @lines = outline.lines
+        @headings = outline.headings
+        @directives = outline.directives
         @error = nil
-      rescue StandardError => e
+      rescue Worker::Error, SystemCallError => e
         @error = e.message
       end
 
@@ -72,34 +83,42 @@ module Raindown
 
       # Headings a directive wrote are part of its output, so they show when it's expanded rather than on their own.
       def items
-        outputs = @document.directives.filter_map(&:output)
-        @document.outline.reject { |item| item.is_a?(Document::Heading) && outputs.any? { it.cover?(item.line) } }
+        outputs = @directives.filter_map(&:output)
+        (@headings + @directives).sort_by(&:line)
+                                 .reject { |item| item.is_a?(Document::Heading) && outputs.any? { it.cover?(item.line) } }
       end
 
       def min_level
-        @document.headings.map(&:level).min || 1
+        @headings.map(&:level).min || 1
       end
 
       def heading_row(heading)
         folded = @folded.include?(heading.line) ? ' …' : ''
         Row.new(text: "#{'#' * heading.level} #{heading.text}#{folded}", depth: heading.level - min_level, kind: :heading,
-                target: heading)
+                target: heading, fold: -> { fold(heading) })
       end
 
       def directive_rows(directive, depth:)
         expanded = @expanded.include?(directive.line)
         row = Row.new(text: directive_text(directive), depth:, kind: :directive, target: directive,
-                      buttons: buttons(directive, expanded:))
+                      buttons: buttons(directive, expanded:), **directive_action(directive))
         return [row] unless expanded
 
-        [row, *directive.output.map do |number|
-          Row.new(text: @lines[number - 1].to_s, depth: depth + 1, kind: :output, target: number)
+        [row, *directive.body.map do |number|
+          Row.new(text: @lines[number - 1].to_s, depth: depth + 1, kind: :body, target: number, open: Edit.new(path:, line: number))
         end]
       end
 
+      # A directive with a body expands it, and one without opens in the editor, like a line of its body.
+      def directive_action(directive)
+        if directive.body then { fold: -> { expand(directive) } }
+        else { open: Edit.new(path:, line: directive.line) }
+        end
+      end
+
       def buttons(directive, expanded:)
         buttons = []
-        buttons << [expanded ? '[-]' : "[+#{directive.output.size}]", :toggle] if directive.output
+        buttons << [expanded ? '[-]' : "[+#{directive.body.size}]", :toggle] if directive.body
         buttons << ['[Run]', :execute] if directive.endpoint?
         buttons
       end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../../actions'
+require_relative '../../bare_directives'
+require_relative '../../chart/chart'
+require_relative '../../document'
+require_relative '../../front_matter'
+require_relative '../../node_blocks'
+require_relative '../../nodes'
+require_relative '../../pages'
+require_relative '../../projects'
+require_relative '../card'
+require_relative '../endpoint'
+require_relative '../../code_blocks'
+require_relative '../../endpoint/curl'
+
+module Raindown
+  module TUI
+    # What the terminal UI asks of a project, answered in the project's Worker with its own nodes loaded,
+    # so two projects' nodes of the same name stay apart. Answers are plain data, which a Worker sends back through a pipe.
+    class Project
+      Outline = Data.define(:lines, :headings, :directives)
+
+      attr_reader :root
+
+      # The projects inside this one have workers of their own, so their files are left out.
+      def initialize(root:)
+        @root = root
+        @load_errors = []
+        @file_errors = []
+        Nodes.load(File.join(root, Nodes::FOLDER))
+      rescue StandardError, ScriptError => e
+        @load_errors << "#{File.basename(root)}/#{Nodes::FOLDER}: #{e.message}"
+      end
+
+      # A file's lines, headings and directives.
+      def outline(path)
+        document = Document.read(path)
+        Outline.new(lines: File.readlines(path, chomp: true), headings: document.headings, directives: document.directives)
+      end
+
+      # Every chart in the project's files, drawn from its data, and the files that couldn't be read.
+      # The charts are found again when asked, and otherwise drawn again, so they follow changes to their data.
+      def charts(find: false)
+        if find || @charts.nil?
+          @file_errors = []
+          @charts = Projects.files(root).flat_map { |path| charts_in(path) }
+        end
+
+        { cards: drawn, errors: @load_errors + @file_errors }
+      end
+
+      # Every endpoint in the project's files, by its request, leaving out the ones whose snippet can't be read.
+      def endpoints
+        Projects.files(root).flat_map do |path|
+          lines = File.readlines(path, encoding: Encoding::UTF_8)
+          Document.read(path).directives.select(&:endpoint?).filter_map { |directive| endpoint(path, lines, directive) }
+        rescue StandardError
+          []
+        end
+      end
+
+      def write_back(path)
+        Actions.write_back(path)
+      end
+
+      # Runs the endpoint on the line, replacing its response.
+      def execute(path, line)
+        directive = Document.read(path).directives.find { it.line == line && it.endpoint? }
+        raise Actions::NotAnEndpoint, "There's no endpoint on line #{line}" unless directive
+
+        Actions.execute(path, directive)
+      end
+
+      private
+
+      def endpoint(path, lines, directive)
+        snippet = CodeBlocks.endpoint(lines, directive.line).first&.dig(:body)
+        request = Curl.request(snippet.to_s)
+        Endpoint.new(project: root, path:, line: directive.line, **request.to_h) if request
+      end
+
+      def charts_in(path)
+        content = File.read(path, encoding: Encoding::UTF_8)
+        bare = BareDirectives.enabled?(path:, content:)
+        lines = content.lines
+        headings = Document.parse(content, bare:).headings
+
+        NodeBlocks.find(lines, front_matter: FrontMatter.parse(content).first, bare:)
+                  .select { |block| block[:node].is_a?(Raindown::Chart) }
+                  .map { |block| chart(block, path:, lines:, headings:) }
+      rescue StandardError => e
+        @file_errors << "#{path.delete_prefix(File.join(root, ''))}: #{e.message}"
+        []
+      end
+
+      def drawn
+        pages = {}
+        @charts.map do |chart|
+          lines = lines(chart, pages[File.dirname(chart[:path])] ||= Pages.for(chart[:path]))
+          Card.new(project: root, chart: lines, **chart.except(:node))
+        end
+      end
+
+      def chart(block, path:, lines:, headings:)
+        line = block[:open] + 1
+        directive = lines[block[:open]].strip.delete_prefix('<{').delete_suffix('}>').strip
+
+        { path:, line:, heading: headings.select { it.line < line }.last&.text, directive:, node: block[:node] }
+      end
+
+      # Draws the chart as its Markdown would be written back, with the files its project lists.
+      def lines(chart, metadata)
+        node = chart[:node]
+        points = node.points(metadata:)
+        points.empty? ? ['No data'] : node.draw(points).map(&:rstrip)
+      rescue StandardError => e
+        ["Can't chart: #{e.message}"]
+      end
+    end
+  end
+end

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

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  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