raindown 0.6.0 → 0.8.0

data/lib/raindown/tui/text.rb

@@ -8,6 +8,16 @@ module Raindown
     module Text
       Segment = Data.define(:text, :style, :event)
       INDENT = '  '
+      WIDTHS = 10_000
+
+      # Printable ASCII, like most code and labels, is a column a character, without asking Unicode, and other text,
+      # like boxes' borders and magnified digits, is the same every frame, so its width's remembered, up to WIDTHS texts.
+      def self.display_width(text)
+        return text.length if text.match?(/\A[ -~]*\z/)
+
+        @widths = {} if @widths.nil? || @widths.size >= WIDTHS
+        @widths[text] ||= Unicode::DisplayWidth.of(text)
+      end
 
       private
 
@@ -27,7 +37,9 @@ module Raindown
       # Text cut or padded to the width, with a cut shown by an ellipsis.
       def fit(text, width)
         return '' if width <= 0
-        return text + (' ' * (width - display_width(text))) if display_width(text) <= width
+
+        text_width = display_width(text)
+        return text + (' ' * (width - text_width)) if text_width <= width
 
         cut = +''
         cut_width = 0
@@ -50,34 +62,72 @@ module Raindown
         end
       end
 
+      # A line of highlighted code's [text, style] parts as segments, cut or padded to the width.
+      def code_segments(parts, width, event: nil)
+        segments = segments_between(parts.map { |text, style| Segment.new(text: printable(text), style:, event:) }, 0, width)
+        [*segments, segment('', :code, width: width - segments.sum { display_width(it.text) }, event:)]
+      end
+
+      # The text in lines that fit the width, broken at spaces where it can, and inside a word too long for a line.
+      def wrap(text, width)
+        return [text] unless width.positive?
+
+        text.scan(/\S+|\s+/).each_with_object([+'']) do |part, lines|
+          next lines.last << part if display_width(lines.last + part) <= width
+          next lines << +'' if part.strip.empty?
+
+          lines << +'' unless lines.last.empty?
+          break_word(part, width, lines)
+        end
+      end
+
+      # Adds a word too long for a line to the lines, a character at a time, starting a new line when one's full.
+      def break_word(word, width, lines)
+        word.each_char do |char|
+          lines << +'' if display_width(lines.last + char) > width
+          lines.last << char
+        end
+      end
+
       # The line's segments, with others drawn over its columns from the column on, like a box over the screen.
       def overlay_segments(line, segments, column:)
         width = segments.sum { display_width(it.text) }
         [*segments_between(line, 0, column), *segments, *segments_between(line, column + width, Float::INFINITY)]
       end
 
-      # The parts of the line's segments between two columns, where a wide character cut in two leaves spaces.
+      # The parts of the line's segments between two columns, where a wide character cut in two leaves spaces. A segment
+      # wholly between them, or wholly outside, is kept or left out whole, without going through its characters.
       def segments_between(line, from, to)
         column = 0
         line.filter_map do |segment|
-          text = segment.text.each_char.map do |char|
-            start = column
-            column += display_width(char)
-            overlap = [column, to].min - [start, from].max
-            overlap == display_width(char) ? char : ' ' * [overlap, 0].max
-          end.join
-          segment.with(text:) unless text.empty?
+          start = column
+          column += display_width(segment.text)
+          next if segment.text.empty? || column <= from || start >= to
+          next segment if start >= from && column <= to
+
+          segment.with(text: chars_between(segment.text, start, from, to))
         end
       end
 
+      # The text's characters between two columns, from the column it starts at, where a wide character cut in two
+      # leaves spaces.
+      def chars_between(text, column, from, to)
+        text.each_char.map do |char|
+          start = column
+          column += display_width(char)
+          overlap = [column, to].min - [start, from].max
+          overlap == display_width(char) ? char : ' ' * [overlap, 0].max
+        end.join
+      end
+
       # Tabs and control characters, like in a directive's output, would move the terminal's cursor.
       def printable(text)
+        return text unless text.match?(/[[:cntrl:]]/)
+
         text.gsub("\t", INDENT).gsub(/[[:cntrl:]]/, '')
       end
 
-      def display_width(text)
-        Unicode::DisplayWidth.of(text)
-      end
+      def display_width(text) = Text.display_width(text)
     end
   end
 end

data/lib/raindown/tui/title.rb

@@ -6,7 +6,7 @@ module Raindown
     module Title
       # The rain cloud without the emoji variation selector, like the nav's projects, which terminals draw one column wide,
       # as it's measured, so the title line reaches the edge.
-      NAME = '🌧 Raindown'
+      NAME = '🌧  Raindown'
 
       private
 

data/lib/raindown/tui/views/dashboard_view.rb

@@ -5,9 +5,9 @@ require_relative '../events'
 module Raindown
   module TUI
     # Every chart in the projects' Markdown files, drawn from its data by its project's Worker, as cards in a grid
-    # with a cursor. A chart is a chart: directive, or a project's own node that's a Raindown::Chart,
-    # like "Sales < Raindown::Chart". Charts are drawn again every few seconds, so they follow changes to their data,
-    # like a CSV file, without a save.
+    # with a cursor. A chart is a chart: directive, or a project's own node that's a Raindown::Chart, like
+    # "Sales < Raindown::Chart", or a Raindown::Stat, one big number, like "CodeDebt < Raindown::Stat". Charts are drawn
+    # again every few seconds, so they follow changes to their data, like a CSV file, without a save.
     # A key's next step, for the Navigator, is nil, or an Open or Edit of a chart's directive.
     class DashboardView
       # Seconds between drawing the charts again.
@@ -31,6 +31,8 @@ module Raindown
       def target = self
       def path = nil
       def changed? = false
+      def typing? = false
+      def pace(_hovered) = :active
 
       def status(_navigator)
         found = "#{charts.length} #{charts.length == 1 ? 'chart' : 'charts'} in #{File.basename(project || root)}"
@@ -45,7 +47,7 @@ module Raindown
 
       # The charts, as each project's Worker drew them, of the project they're narrowed to, if any.
       def charts
-        project ? @cards.select { it.project == project } : @cards
+        project ? @cards.filter { it.project == project } : @cards
       end
 
       # Narrows the charts to a project's, or with nil, shows every project's.
@@ -109,7 +111,7 @@ module Raindown
           answer = worker.call(:charts, find:)
           @cards.concat(answer[:cards])
           @errors.concat(answer[:errors])
-        rescue Worker::Error => e
+        rescue Workers::Worker::Error => e
           @errors << "#{File.basename(worker.root)}: #{e.message}"
         end
         @cards.sort_by! { [it.project, it.path, it.line] }

data/lib/raindown/tui/views/endpoint_view.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../events'
-require_relative '../workers/worker'
+require_relative '../../workers/worker'
 
 module Raindown
   module TUI
@@ -26,6 +26,8 @@ module Raindown
       def path = endpoint.path
       def status(_navigator) = [:info, endpoint.text]
       def changed? = false
+      def typing? = false
+      def pace(_hovered) = :active
       def next_step?(key) = %i[up down enter edit execute].include?(key)
 
       # Clicks on the response only move the focus to it.
@@ -38,7 +40,7 @@ module Raindown
         @language = lines.first.to_s[FENCE, 1]
         @response = @language ? lines[1...-1] : lines
         @error = nil
-      rescue Worker::Error => e
+      rescue Workers::Worker::Error => e
         @response = []
         @error = e.message
       end

data/lib/raindown/tui/views/list_view.rb

@@ -13,6 +13,8 @@ module Raindown
       end
 
       def renderer = ListRenderer
+      def typing? = false
+      def pace(_hovered) = :active
 
       def rows = @rows.call
       def selected = rows[cursor]

data/lib/raindown/tui/views/outline_view.rb

@@ -3,8 +3,9 @@
 require_relative '../../document'
 require_relative '../events'
 require_relative 'list_view'
+require_relative '../highlighter'
 require_relative '../row'
-require_relative '../workers/worker'
+require_relative '../../workers/worker'
 
 module Raindown
   module TUI
@@ -34,8 +35,9 @@ module Raindown
         @lines = outline.lines
         @headings = outline.headings
         @directives = outline.directives
+        @highlighted = {}
         @error = nil
-      rescue Worker::Error, SystemCallError => e
+      rescue Workers::Worker::Error, SystemCallError => e
         @error = e.message
       end
 
@@ -104,11 +106,18 @@ module Raindown
                       buttons: buttons(directive, expanded:), **directive_action(directive))
         return [row] unless expanded
 
-        [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))
+        code = highlighted(directive)
+        [row, *directive.body.each_with_index.map do |number, index|
+          Row.new(text: @lines[number - 1].to_s, depth: depth + 1, kind: :body, target: number, open: Edit.new(path:, line: number),
+                  code: code[index])
         end]
       end
 
+      # The directive's body highlighted as Markdown, which highlights its code blocks in their languages, once a read.
+      def highlighted(directive)
+        @highlighted[directive.line] ||= Highlighter.lines(directive.body.map { @lines[it - 1].to_s }, language: 'markdown')
+      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) } }
@@ -119,12 +128,13 @@ module Raindown
       def buttons(directive, expanded:)
         buttons = []
         buttons << [expanded ? '[-]' : "[+#{directive.body.size}]", :toggle] if directive.body
-        buttons << ['[Run]', :execute] if directive.endpoint?
+        buttons << ['[Run]', :execute] if directive.endpoint? && directive.writes
         buttons
       end
 
+      # A self-closing directive, like <{ :toc }>, by its name after a colon, and the rest by theirs before one.
       def directive_text(directive)
-        return ":#{directive.name}" unless directive.writes
+        return ":#{directive.name}" if !directive.writes && directive.line == directive.end_line
 
         [directive.name, ':', (" #{directive.args}" unless directive.args.empty?)].join
       end

data/lib/raindown/tui.rb

@@ -4,26 +4,38 @@ require_relative 'projects'
 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,
+  # The terminal UI, started with "raindown": a project's Markdown files beside the open file's outline,
   # where directives fold, endpoints run and the editor opens at a line. Curses only loads here,
   # so watching and rendering start without it.
   module TUI
     module_function
 
-    # 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)
+    # PATH is a file to open, or a directory. Its project is the one it's in, or else the directory itself. It returns
+    # true once it's quit. Without a terminal, like in a script or a service, it says so, once curses has loaded, and returns false, to be
+    # watched instead, as curses' own error would be "Error opening terminal: unknown". Bare and execute, like --bare and
+    # -x, allow bare directives in any file and run endpoints with no response as it writes back.
+    def start(path, bare: false, execute: false)
       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?
+      unless $stdin.tty? && $stdout.tty?
+        warn("raindown needs a terminal, so it's watching instead")
+        return false
+      end
 
       path = File.expand_path(path)
       root = Projects.root(path) || (File.directory?(path) ? path : File.dirname(path))
       # 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:)
+      workers = Project.workers(root:, bare:, execute:)
 
-      Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)), workers:)).run
+      # Rouge loads here, rather than with Raindown, which doesn't highlight code outside the TUI.
+      require 'rouge'
+      # Saved files are written back, like when the folder's watched.
+      require_relative 'tui/saves'
+      saves = Saves.new(root)
+      Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)), workers:, saves:, runs_endpoints: execute)).run
+      true
     ensure
+      saves&.stop
       workers&.stop
     end
   end

data/lib/raindown/watcher/changes.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../projects'
+
+module Raindown
+  module Watcher
+    # Listening skips these folders as they hold dependencies and builds, which Projects ignores too.
+    IGNORE = %r{(?:\A|/)(?:#{Projects::IGNORED.join('|')})/}
+
+    # A change to a project's nodes, or to one of its Markdown files, which is written back when it's been saved.
+    Change = Data.define(:root, :path, :nodes) do
+      def nodes? = nodes
+      def saved? = !nodes && File.exist?(path)
+    end
+
+    # A listener, still to start, that gives the block the paths saved, added or removed in the directory.
+    def self.listen(directory, &)
+      require 'listen'
+      Listen.to(directory, ignore: IGNORE) { |modified, added, removed| yield(modified + added + removed) }
+    end
+
+    # The changes among the paths, by the project each is in, the nearest one above it, or else the root, when there is
+    # one, leaving out files that are neither nodes nor Markdown, or are in ignored folders.
+    def self.changes(paths, root: nil)
+      paths.filter_map do |path|
+        project = Projects.root(path) || root || next
+        next Change.new(root: project, path:, nodes: true) if Projects.node?(path, root: project)
+
+        Change.new(root: project, path:, nodes: false) if Projects.markdown?(path, root: project)
+      end
+    end
+  end
+end

data/lib/raindown/watcher/file_watcher.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../../raindown'
+require_relative '../rewriter'
+require_relative 'changes'
+
+module Raindown
+  module Watcher
+    # Watches one file and writes back to it as it's saved, like its TOC, tables and endpoint responses.
+    class FileWatcher
+      attr_reader :path, :bare, :execute
+
+      def initialize(path:, bare: false, execute: false)
+        @path = path
+        @bare = bare
+        @execute = execute
+      end
+
+      def start
+        $stdout.sync = true
+
+        safely { rewrite }
+        puts "Watching #{path} for changes..."
+
+        listener.start
+        sleep
+      end
+
+      private
+
+      def listener
+        directory = File.dirname(File.expand_path(path))
+        filename = File.basename(path)
+
+        Watcher.listen(directory) do |paths|
+          next unless paths.any? { File.basename(it) == filename && File.exist?(it) }
+
+          # Writing back saves the file again, and that save changes nothing, so it ends there.
+          safely { puts "Updated #{path}" if rewrite }
+        end
+      end
+
+      # An error in the file is shown rather than stopping the watcher, so it can be fixed and saved again.
+      def safely
+        yield
+      rescue StandardError => e
+        raise if ENV['RAINDOWN_DEBUG']
+
+        warn "raindown: #{path}: #{e.message}"
+      end
+
+      # 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))
+      end
+    end
+  end
+end

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