raindown 0.8.1 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fab4cc96057c97d8a6c5ef07b11e12fda146e25855ac2015f667e838b1c805d
-  data.tar.gz: 1b9044d112a1d05773bb22bfdc4767264ad190c24bceb49b82733ecd1989a026
+  metadata.gz: 3288235ed874ddbeae5b31b5ef6707e59864f5cca305bb9bc74fcf74a9c36366
+  data.tar.gz: c7bfc9dcdec92857c433d4abacbc80d221bb6029617972d362af43163c235c39
 SHA512:
-  metadata.gz: 1cf8132950f24d3005113635835426471514a7c79312cac8379e66d93c3345b32e9788e2f86c73eb80e4050d757eab4bcb7c08ef8ad6a3c41aad2808493a6c5b
-  data.tar.gz: f1c47f511df4d7d9725c60f30fb0e3a0af3e762e197d510ec55eafe9ad01db51f0cefa6b6b2a684e1e5a37fb2654fbe1c8fc91c07e8b5a815e576df51b617682
+  metadata.gz: 1cb1aaaf0f325d154393656cad4040aa8a2205464e577ce69f23931bd2f2727d28222aba9a6d3a059bd2f7531e59050f0056b413a1a72cb72fe66e5e785b300a
+  data.tar.gz: f89b1e87119328272a1df69a6c2f9c04159f98db03c749774bac1ae533307eff32bc833b111c41ef569456ed9e0f2ec421afc938744b31102e4f6c8c848fcace

data/lib/raindown/actions.rb

@@ -31,7 +31,7 @@ module Raindown
       raise NotAnEndpoint, "#{directive.name} on line #{directive.line} isn't an endpoint" unless directive.endpoint?
       raise NotAnEndpoint, "The endpoint on line #{directive.line} only renders, so put it in comments to run it" unless directive.writes
 
-      content = File.read(path, encoding: Encoding::UTF_8)
+      content = Utils.read_markdown(path)
       rewritten = EndpointRunner.new(content:, bare: BareDirectives.enabled?(path:, content:), only: directive.line - 1).rewrite
       return false if rewritten == content
 

data/lib/raindown/document.rb

@@ -39,7 +39,7 @@ module Raindown
     # they're allowed, like with --bare.
     # A project's own nodes are only directives once they're loaded, like with Nodes.load(path), the same as when the file renders.
     def self.read(path, bare: false)
-      new(markdown: File.read(path, encoding: Encoding::UTF_8), bare: bare || BareDirectives.file?(path))
+      new(markdown: Utils.read_markdown(path), bare: bare || BareDirectives.file?(path))
     end
 
     def initialize(markdown:, bare: false)

data/lib/raindown/gitignore.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Raindown
+  # The folders .gitignore files leave out, like a Drupal site's web/core, so finding the projects in a folder of
+  # them, like ~/dev, skips them. Only lines naming a folder are read, like /vendor/, node_modules or
+  # /web/modules/contrib/*, as a wildcard could leave out a project, and a ! takes a folder back out.
+  class Gitignore
+    WILDCARD = /[*?\[]/
+
+    # The rules for the folders inside a folder: its .gitignore's and those of the folders above it, up to its
+    # repository, as a repository's rules don't reach the repositories inside it.
+    def initialize(folder, above = nil)
+      above = nil if File.exist?(File.join(folder, '.git'))
+      @paths = Set.new(above&.paths)
+      @names = Set.new(above&.names)
+      file = File.join(folder, '.gitignore')
+      File.foreach(file, chomp: true) { read(it.strip, folder) } if File.file?(file)
+    end
+
+    def ignores?(path)
+      @paths.include?(path) || @names.include?(File.basename(path))
+    end
+
+    protected
+
+    attr_reader :paths, :names
+
+    private
+
+    # A folder with a slash, like /vendor or web/files, is from the .gitignore's folder, and one without, like
+    # node_modules, is any folder of that name below it.
+    def read(line, folder)
+      pattern = line.delete_suffix('/*').delete_suffix('/')
+      negated = pattern.delete_prefix!('!')
+      return if pattern.empty? || pattern.start_with?('#') || pattern.match?(WILDCARD)
+
+      if pattern.include?('/')
+        update(@paths, File.join(folder, pattern.delete_prefix('/')), negated:)
+      else
+        update(@names, pattern, negated:)
+      end
+    end
+
+    def update(rules, rule, negated:)
+      return rules.delete(rule) if negated
+
+      rules.add(rule)
+    end
+  end
+end

data/lib/raindown/js/host.mjs

@@ -0,0 +1,51 @@
+// Runs a project's JavaScript Components for Raindown, which starts it with node -e, since inside Raindown's package
+// the script is where NodeJS can't read it. Each line on stdin is a request, answered by one line of JSON on stdout:
+//   { op: 'load', folder }                → { nodes: [{ name, render }] }
+//   { op: 'new', id, name, args, props }  → {}
+//   { op: 'call', id, method, context }   → { value }
+// A request that throws is answered with { error }.
+import { readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { createInterface } from 'node:readline'
+import { pathToFileURL } from 'node:url'
+
+// stdout carries the replies, so what nodes log goes to stderr.
+console.log = console.info = console.error
+
+const classes = {}
+const nodes = {}
+
+const requests = {
+  // Every exported class with replace is a node, named by its export, or by its class for a default export.
+  async load({ folder }) {
+    for (const file of readdirSync(folder).filter((file) => /\.m?js$/.test(file))) {
+      const exports = await import(pathToFileURL(join(folder, file)).href)
+
+      for (const [name, value] of Object.entries(exports)) {
+        if (typeof value?.prototype?.replace === 'function') classes[name === 'default' ? value.name : name] = value
+      }
+    }
+
+    const nodes = Object.entries(classes).map(([name, node]) => ({ name, render: typeof node.prototype.render === 'function' }))
+    return { nodes }
+  },
+
+  new({ id, name, args, props }) {
+    nodes[id] = new classes[name](props, ...args)
+    return {}
+  },
+
+  async call({ id, method, context }) {
+    return { value: await nodes[id][method](context) }
+  },
+}
+
+for await (const line of createInterface({ input: process.stdin })) {
+  const request = JSON.parse(line)
+
+  try {
+    process.stdout.write(`${JSON.stringify(await requests[request.op](request))}\n`)
+  } catch (error) {
+    process.stdout.write(`${JSON.stringify({ error: String(error?.message ?? error) })}\n`)
+  }
+}

data/lib/raindown/js/js_nodes.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+require_relative '../node'
+
+module Raindown
+  # JavaScript Components, the .js and .mjs files in a project's .raindown folder, which export classes with replace and
+  # optionally render, like Ruby nodes. They run in a NodeJS process of Raindown's own, started when a folder has them,
+  # so only projects with JavaScript Components need NodeJS.
+  module JSNodes
+    EXTENSIONS = %w[.js .mjs].freeze
+    SCRIPT = File.join(__dir__, 'host.mjs')
+
+    class Error < StandardError; end
+
+    # The NodeJS process running the nodes, which answers each request with a line of JSON. NodeJS can't read the script
+    # inside Raindown's package, so it's passed to node -e.
+    class Host
+      def initialize
+        @input, @output, = Open3.popen2('node', '--input-type=module', '-e', File.read(SCRIPT))
+      rescue Errno::ENOENT
+        raise Error, 'JavaScript Components need NodeJS 22 or later on your PATH'
+      end
+
+      def request(**message)
+        @input.puts(JSON.generate(message))
+        reply = JSON.parse(@output.gets || raise(Error, 'NodeJS stopped running the JavaScript Components'))
+        raise Error, reply['error'] if reply['error']
+
+        reply
+      end
+    end
+
+    module_function
+
+    # Loads the JavaScript Components in a .raindown folder, starting NodeJS the first time a folder has any.
+    def load(folder)
+      return if Dir.glob(EXTENSIONS.map { "*#{it}" }, base: folder).empty?
+
+      host.request(op: 'load', folder:).fetch('nodes').each do |node|
+        node_classes[node['name']] ||= JSNode.for(name: node['name'], render: node['render'])
+      end
+    end
+
+    def node_class(name)
+      node_classes[name]
+    end
+
+    def host
+      @host ||= Host.new
+    end
+
+    def node_classes
+      @node_classes ||= {}
+    end
+  end
+
+  # A JavaScript Component, made in the NodeJS process with its props, where its replace and render are sent.
+  class JSNode < Node
+    # A class for each JavaScript Component, which renders its own HTML when the component has render.
+    def self.for(name:, render:)
+      Class.new(self) do
+        define_singleton_method(:name) { name }
+        define_method(:render) { |**context| js_output(:render, context) } if render
+      end
+    end
+
+    def initialize(*args, **props)
+      super()
+      JSNodes.host.request(op: 'new', id: object_id, name: self.class.name, args:, props:)
+    end
+
+    def replace(**context)
+      js_output(:replace, context)
+    end
+
+    private
+
+    def js_output(method, context)
+      JSNodes.host.request(op: 'call', id: object_id, method:, context: json_context(**context)).fetch('value').to_s
+    end
+
+    # JSON can't hold Pages, so the metadata is its root and each file's front matter and path.
+    def json_context(metadata: NoMetadata, **context)
+      root = metadata.root if metadata.respond_to?(:root)
+      { **context, metadata: { root:, files: metadata.list.map(&:metadata) } }
+    end
+  end
+end

data/lib/raindown/nodes.rb

@@ -2,13 +2,14 @@
 
 require_relative 'chart/chart'
 require_relative 'files'
+require_relative 'js/js_nodes'
 require_relative 'node'
 require_relative 'stat'
 require_relative 'toc'
 
 module Raindown
   # Nodes are LowNodes that a node block writes into the Markdown and renders into the HTML.
-  # A project keeps them in a .raindown folder, which is loaded with Dirload.
+  # A project keeps them in a .raindown folder, which is loaded with Dirload, beside its JavaScript Components, if any.
   # A node writes Markdown with #replace, and HTML with #render if it has one. Either can take the keywords
   # document: (the Markdown being rendered), metadata: and bare:, and gets the ones it asks for.
   module Nodes
@@ -29,6 +30,7 @@ module Raindown
       require 'dirload'
       loaded << folder
       dirload(folder)
+      JSNodes.load(folder)
     end
 
     def find_folder(directory)
@@ -54,11 +56,12 @@ module Raindown
       loaded_class(BUILT_INS[name]) || Raindown.const_get(BUILT_INS[name])
     end
 
+    # A Ruby node of the name, or else a JavaScript one.
     def loaded_class(name)
-      klass = Object.const_get(name)
-      klass if node?(klass)
-    rescue NameError
-      nil
+      klass = Object.const_get(name) if Object.const_defined?(name)
+      return klass if node?(klass)
+
+      JSNodes.node_class(name)
     end
 
     # A LowNode, or one of Raindown's own nodes, that writes Markdown. In an app, LowNodes are also routes and pages,

data/lib/raindown/page.rb

@@ -17,7 +17,7 @@ module Raindown
     # It follows the file's project config, like render_file, unless the render options say otherwise.
     def content
       @content ||= begin
-        markdown = File.read(file_path, encoding: Encoding::UTF_8)
+        markdown = Utils.read_markdown(file_path)
 
         if FrontMatter.parse(markdown).last.strip.empty? then ''
         else Raindown.render(markdown:, bare: BareDirectives.file?(file_path), **Config.render_options(file_path).merge(@render_options))

data/lib/raindown/pages.rb

@@ -2,6 +2,7 @@
 
 require_relative 'front_matter'
 require_relative 'page'
+require_relative 'utils'
 
 module Raindown
   # The metadata of a project's Markdown files, which list: and files: list by tag.
@@ -62,7 +63,7 @@ module Raindown
     end
 
     def process(file_path:)
-      metadata = implicit_metadata(file_path:).merge(FrontMatter.parse(File.read(file_path, encoding: Encoding::UTF_8)).first)
+      metadata = implicit_metadata(file_path:).merge(FrontMatter.parse(Utils.read_markdown(file_path)).first)
       @metadata[file_path] = metadata
       metadata.each { |type, tag| Array(tag).each { |item| tag(type:, tag: item, file_path:) } }
     end

data/lib/raindown/projects.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'find'
+require_relative 'gitignore'
 require_relative 'nodes'
 require_relative 'pages'
 
@@ -10,22 +11,29 @@ module Raindown
   module Projects
     # Folders of dependencies, builds and tooling, which aren't searched for projects or watched, nor are hidden folders.
     IGNORED = %w[node_modules vendor tmp pkg build dist coverage].freeze
+    # Ruby nodes and JavaScript Components.
+    NODE_EXTENSIONS = ['.rb', '.rbx', *JSNodes::EXTENSIONS].freeze
 
     module_function
 
     # The roots of the projects in a directory: the project the directory is in, if any, and every project below it.
     def roots(directory)
       directory = File.expand_path(directory)
-      roots = [root(directory)].compact
+      [root(directory), *project_folders(directory)].compact.uniq
+    end
 
-      Find.find(directory) do |path|
-        next unless File.directory?(path)
+    # The folders below a directory with a .raindown folder. Only folders are walked, leaving out ignored, linked and
+    # gitignored ones, so it stays quick in a big folder like ~/dev.
+    def project_folders(directory, gitignore = Gitignore.new(directory))
+      Dir.glob('*/', base: directory).flat_map do |folder|
+        path = File.join(directory, folder.chomp('/'))
+        next [] if ignored?(folder.chomp('/')) || File.symlink?(path) || gitignore.ignores?(path)
 
-        Find.prune if path != directory && ignored?(File.basename(path))
-        roots << path if File.directory?(File.join(path, Nodes::FOLDER))
-      end
+        inside = project_folders(path, Gitignore.new(path, gitignore))
+        next inside unless project?(path)
 
-      roots.uniq
+        [path, *inside]
+      end
     end
 
     # The root of the project a file or directory is in, or nil when it isn't in one.
@@ -36,13 +44,13 @@ module Raindown
     end
 
     # The project's Markdown files, sorted, leaving out ignored folders. The projects inside it are left out too,
-    # since they have nodes of their own, unless they're asked for, like by the terminal UI, which lists them all.
-    def files(root, nested: false)
+    # since they have nodes of their own.
+    def files(root)
       files = []
 
       Find.find(root) do |path|
         if File.directory?(path)
-          Find.prune if path != root && (ignored?(File.basename(path)) || (!nested && project?(path)))
+          Find.prune if path != root && (ignored?(File.basename(path)) || project?(path))
         elsif markdown?(path, root:)
           files << path
         end
@@ -61,7 +69,12 @@ module Raindown
 
     # Whether a file is one of a project's own nodes, which load when its watcher starts.
     def node?(path, root:)
-      File.expand_path(path).start_with?(File.join(root, Nodes::FOLDER, '')) && %w[.rb .rbx].include?(File.extname(path))
+      File.expand_path(path).start_with?(File.join(root, Nodes::FOLDER, '')) && NODE_EXTENSIONS.include?(File.extname(path))
+    end
+
+    # The roots that aren't inside another of them, as a project's code includes the projects inside it.
+    def outer_roots(roots)
+      roots.reject { |root| roots.any? { root != it && root.start_with?(File.join(it, '')) } }
     end
 
     def project?(folder)

data/lib/raindown/rewriter.rb

@@ -3,6 +3,7 @@
 require_relative 'node_injector'
 require_relative 'endpoint/endpoint_runner'
 require_relative 'table_formatter'
+require_relative 'utils'
 
 module Raindown
   # Rewrites the generated parts of a Markdown file in place before it's rendered:
@@ -21,7 +22,7 @@ module Raindown
 
     # Returns true when the file changed.
     def update(path:, bare: false, execute: false, metadata: NoMetadata)
-      content = File.read(path, encoding: Encoding::UTF_8)
+      content = Utils.read_markdown(path)
       rewritten = rewrite(content:, path:, bare:, execute:, metadata:)
       return false if rewritten == content
 

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

@@ -3,6 +3,7 @@
 require_relative '../code_box'
 require_relative '../events'
 require_relative '../../blueprints'
+require_relative '../../projects'
 require_relative 'traced_code'
 require_relative 'canvas'
 require_relative 'code_comments'
@@ -32,9 +33,10 @@ module Raindown
 
       attr_reader :cursor
 
-      def initialize(root:)
+      def initialize(root:, projects: [root])
         @root = root
-        @path = File.join(root, Blueprints::FILE)
+        @projects = projects
+        @paths = projects.map { File.join(it, Blueprints::FILE) }
         @all = []
         @cursor = 0
         select_box(0)
@@ -51,7 +53,7 @@ module Raindown
       end
 
       # Whether there are any blueprints yet, saved or in the code's comments, which are looked for once until it's loaded.
-      def any? = File.exist?(@path) || commented.any?
+      def any? = @paths.any? { File.exist?(it) } || commented.any?
 
       # Whether the file's changed since it was read, so it's read again on the next tick.
       def changed? = mtime != @read_at
@@ -60,13 +62,26 @@ module Raindown
         @read_at = mtime
         newest = @all.first&.time
         @commented = nil
-        @all = Blueprints.read(@root) + commented
+        @all = saved + commented
         self.cursor = 0 unless @all.first&.time == newest
         self.cursor = @cursor
       end
 
       def selected = blueprints[@cursor]
 
+      # Narrows the blueprints to a project's, or with nil, shows every project's.
+      def project=(project)
+        @project = project
+        self.cursor = 0
+      end
+
+      # The blueprints in the project they're narrowed to, if any, which the filter's keywords narrow further.
+      def in_project
+        return @all unless @project
+
+        @all.select { File.expand_path(it.path, @root).start_with?(File.join(@project, '')) }
+      end
+
       # Another blueprint's shown from its first box, while the same one keeps its box and canvas, like when it's clicked.
       def cursor=(index)
         shown = selected
@@ -115,7 +130,7 @@ module Raindown
         method = code
         return Edit.new(path: method.path, line: method.line) if method
 
-        Edit.new(path: File.join(@root, selected.path), line: selected.line)
+        Edit.new(path: File.expand_path(selected.path, @root), line: selected.line)
       end
 
       # A click on a box drawn in the blueprint, which moves on to the next code it names when it's already selected.
@@ -138,9 +153,20 @@ module Raindown
 
       def count(number, noun) = "#{number} #{number == 1 ? noun : "#{noun}s"}"
 
-      def mtime = File.exist?(@path) ? File.mtime(@path) : nil
+      def mtime = @paths.map { File.exist?(it) ? File.mtime(it) : nil }
+
+      # Every project's saved blueprints, newest first, each by its file from the root.
+      def saved
+        @projects.flat_map { |project| Blueprints.read(project).map { it.with(path: from_root(File.join(project, it.path))) } }
+                 .sort_by(&:time).reverse
+      end
+
+      def from_root(path) = path.delete_prefix(File.join(@root, ''))
+
+      # The projects whose code is read, as a project's code includes the projects inside it.
+      def code_projects = @code_projects ||= Projects.outer_roots(@projects)
 
-      def commented = @commented ||= CodeComments.blueprints(@root)
+      def commented = @commented ||= CodeComments.blueprints(@root, projects: code_projects)
     end
   end
 end

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

@@ -16,9 +16,10 @@ module Raindown
 
       module_function
 
-      # The blueprints in the comments of the project's code, by file, from the top of each.
-      def blueprints(root)
-        CodeMethods.files(root).flat_map { |path| in_file(path, path.delete_prefix(File.join(root, ''))) }
+      # The blueprints in the comments of the projects' code, by file from the root, from the top of each. In a folder of
+      # projects, like ~/dev, only the projects' code is read.
+      def blueprints(root, projects: [root])
+        projects.flat_map { CodeMethods.files(it) }.flat_map { |path| in_file(path, path.delete_prefix(File.join(root, ''))) }
       end
 
       def in_file(path, relative)

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

@@ -15,10 +15,11 @@ module Raindown
 
       def typing? = @filtering == true
 
-      # The blueprints with every keyword, or all of them, filtered again only when the keywords or the blueprints change,
+      # The blueprints with every keyword, or all of them, in the project they're narrowed to, if any, filtered again only when
+      # the keywords, the project or the blueprints change,
       # as what's drawn asks for the selected one many times a frame.
       def blueprints
-        @filtered = [query, @all, filtered(query.to_s.downcase.split)] unless filtered_now?
+        @filtered = [query, @all, @project, filtered(query.to_s.downcase.split)] unless filtered_now?
         @filtered.last
       end
 
@@ -38,12 +39,12 @@ module Raindown
 
       private
 
-      def filtered_now? = @filtered && @filtered[0] == query && @filtered[1].equal?(@all)
+      def filtered_now? = @filtered && @filtered[0] == query && @filtered[1].equal?(@all) && @filtered[2] == @project
 
       def filtered(keywords)
-        return @all if keywords.empty?
+        return in_project if keywords.empty?
 
-        @all.select { |blueprint| keywords.all? { blueprint.words.downcase.include?(it) || blueprint.kind.include?(it) } }
+        in_project.select { |blueprint| keywords.all? { blueprint.words.downcase.include?(it) || blueprint.kind.include?(it) } }
       end
 
       def open_filter

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

@@ -50,7 +50,8 @@ module Raindown
 
       def first_method(owner) = methods.select { it.owner == owner }.min_by { [it.path, it.line] }
 
-      def methods = @methods ||= CodeMethods.list(@root)
+      # The projects' methods. In a folder of projects, like ~/dev, only the projects' code is read.
+      def methods = @methods ||= code_projects.flat_map { CodeMethods.list(it) }
     end
   end
 end

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

@@ -18,7 +18,7 @@ module Raindown
 
       # The five bins, each a box with its number, its temper, and a bar of how many feelings it holds.
       def bins
-        counts = view.log.counts
+        counts = view.counts
         most = [counts.values.max, 1].max
         chosen = chosen_temper
         boxes = counts.each_with_index.map { |(temper, count), index| bin(index + 1, temper, count, most, chosen) }

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

@@ -41,9 +41,24 @@ module Raindown
 
       module_function
 
+      # Git log runs in a thread of its own while the methods are read, as it's as slow as reading them. Waiting on git's
+      # output frees the main thread to read, and the two meet when each method gets its file's changes, for its drift:
+      #   Thread                                  main thread
+      #   ┌──────────────────────────┐            ┌─────────────────────────┐
+      #   │ CodeMethods.file_changes │            │ CodeMethods.tagged      │
+      #   │ git log, in a subprocess │            │ or CodeMethods.indented │
+      #   └────────────┬─────────────┘            └────────────┬────────────┘
+      #                │ changes.value waits for it            │
+      #                └───────────────────┬───────────────────┘
+      #                                    │
+      #                                    ▼
+      #                         ┌──────────────────────┐
+      #                         │ CodeMethods.drifting │
+      #                         └──────────────────────┘
       def list(root)
-        changes = file_changes(root)
-        drifting((tagged(root) || indented(root)).map { it.with(changes: changes.fetch(it.path, 0)) })
+        changes = Thread.new { file_changes(root) }
+        methods = tagged(root) || indented(root)
+        drifting(methods.map { it.with(changes: changes.value.fetch(it.path, 0)) })
       end
 
       # Each method with its drift, from 0 for the lightest to 9 for the heaviest, where methods that weigh the same

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

@@ -81,9 +81,9 @@ module Raindown
       # How the method last felt, while its code's the same as when it was felt, or nil.
       def temper(method) = rows.reverse.find { felt_row?(it, method) }&.fetch(:temper)
 
-      # How many feelings there are of each temper, in the bins' order.
-      def counts
-        tally = rows.map { it[:temper] }.tally
+      # How many feelings there are of each temper, in the bins' order, of those within a folder, like a project, if one's given.
+      def counts(within: nil)
+        tally = rows.select { within.nil? || File.join(@root, path(it)).start_with?(File.join(within, '')) }.map { it[:temper] }.tally
         TEMPERS.to_h { [it, tally.fetch(it, 0)] }
       end
 
@@ -132,5 +132,33 @@ module Raindown
         nil
       end
     end
+
+    # The feelings about each project's code, in its own FeelingsLog, so in a folder of projects, like ~/dev, each project
+    # keeps its own feelings, and the folder isn't made a project.
+    class FeelingsLogs
+      def initialize(projects:)
+        @logs = projects.to_h { [it, FeelingsLog.new(root: it)] }
+      end
+
+      def add(feeling) = log_of(feeling.method).add(feeling)
+      def felt?(method) = log_of(method).felt?(method)
+      def temper(method) = log_of(method).temper(method)
+      def rows = @logs.values.flat_map(&:rows)
+
+      # Each project's feelings about methods that have changed, or gone, from its methods there are now, to its memories.
+      def move_stale_to_memories(methods)
+        by_log = methods.group_by { log_of(it) }
+        @logs.each_value { it.move_stale_to_memories(by_log.fetch(it, [])) }
+      end
+
+      def counts(within: nil)
+        empty = FeelingsLog::TEMPERS.to_h { [it, 0] }
+        @logs.values.map { it.counts(within:) }.reduce(empty) { |sum, counts| sum.merge(counts) { |_, felt, more| felt + more } }
+      end
+
+      private
+
+      def log_of(method) = @logs.find { |root, _| method.path.start_with?(File.join(root, '')) }&.last
+    end
   end
 end

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

@@ -76,9 +76,10 @@ module Raindown
 
       def view = navigator.view
 
-      # Instead of the grid, that there's nothing to feel, or the celebration.
+      # Instead of the grid, that there's nothing to feel, as there are no projects or no methods, or the celebration.
       def instead
-        return blank(" No functions or methods in #{File.basename(navigator.root)} to feel") if view.code_methods.empty?
+        return alert(NO_PROJECTS) if navigator.projects.empty?
+        return alert(["No functions or methods in #{File.basename(navigator.root)} to feel."]) if view.code_methods.empty?
 
         celebration(view.celebration)
       end
@@ -174,10 +175,6 @@ module Raindown
         lines[(height - shown.length) / 2, shown.length] = shown
         lines.map { [segment(it.center(width), :too_small)] }
       end
-
-      def blank(message)
-        [[segment(message, :feelings)], *Array.new([height - 1, 0].max) { [segment('', :blank)] }].first(height)
-      end
     end
   end
 end

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

@@ -29,12 +29,13 @@ module Raindown
       KEYS = %i[up down left right edit execute enter toggle expand celebrate].freeze
 
       # The temper being noted, and the note typed so far, while it's asking why, whether the selected method's code
-      # shows all that fits, until another's selected, and the rain then the waffle, once the batch is refined.
-      attr_reader :noting, :note, :cursor, :log, :celebration
+      # shows all that fits, until another's selected, the rain then the waffle, once the batch is refined, and the project
+      # its methods and counts are narrowed to, if any.
+      attr_reader :noting, :note, :cursor, :log, :celebration, :project
 
-      def initialize(root:)
-        @root = root
-        @log = FeelingsLog.new(root:)
+      def initialize(projects:)
+        @projects = projects
+        @log = FeelingsLogs.new(projects:)
         @last_feelings = {}
         @cursor = 0
         @week = WeeklyBatch.new(log: @log)
@@ -63,12 +64,20 @@ module Raindown
       # the memories.
       def load
         was = selected
-        every = CodeMethods.list(@root)
-        @log.move_stale_to_memories(every)
-        @week.read(every)
+        @every = @projects.flat_map { CodeMethods.list(it) }
+        @log.move_stale_to_memories(@every)
+        @week.read(in_project)
         reselect(was)
       end
 
+      # Narrows the methods to a project's, or with nil, shows every project's, picking the batch again from them.
+      def project=(project)
+        @project = project
+        @week.read(in_project)
+        @week.pick_again
+        self.cursor = 0
+      end
+
       # Selects the method again, by its file and name, wherever it is now, or keeps the cursor where it was.
       def reselect(was)
         self.cursor = code_methods.index { [it.path, it.label] == [was&.path, was&.label] } || @cursor
@@ -78,6 +87,9 @@ module Raindown
       def batch = @week.batch
       def code_methods = batch.code_methods
 
+      # How many feelings there are of each temper, in the project the methods are narrowed to, if any.
+      def counts = log.counts(within: project)
+
       def selected = code_methods[@cursor]
 
       def cursor=(index)
@@ -106,6 +118,11 @@ module Raindown
 
       private
 
+      # The methods of the project they're narrowed to, if any, which are none until they're read.
+      def in_project
+        @every.to_a.select { @project.nil? || it.path.start_with?(File.join(@project, '')) }
+      end
+
       # Moves between the methods, or acts on the selected one.
       def method_step(key)
         case key

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

@@ -38,6 +38,11 @@ module Raindown
         refill(grid_cells)
       end
 
+      # Picks the batch again on the next fill, like when the methods are narrowed to a project's.
+      def pick_again
+        @filled_for = nil
+      end
+
       private
 
       def refill(grid_cells)

data/lib/raindown/tui/file_tree.rb

@@ -28,8 +28,8 @@ module Raindown
       PROJECT = '🌧'
 
       def load
-        @files = Projects.files(root, nested: true)
-        @projects = Projects.roots(root).to_set
+        @projects = @workers.roots
+        @files = @projects.flat_map { Projects.files(it) }.sort
       end
 
       # The folder the tree starts from: the scope's, or the root's.

data/lib/raindown/tui/navigator/navigator.rb

@@ -45,10 +45,10 @@ module Raindown
         @files = FileTree.new(root:, workers:)
         @endpoints = Endpoints.new(workers:)
         @dashboard = DashboardView.new(root:, workers:)
-        @feelings = FeelingsView.new(root:)
-        @blueprints = BlueprintsView.new(root:)
+        @feelings = FeelingsView.new(projects: Projects.outer_roots(workers.roots))
+        @blueprints = BlueprintsView.new(root:, projects: workers.roots)
         @nav = ListView.new { nav_rows }
-        first = Projects.files(root, nested: true).first
+        first = @files.files.first
         # The dashboard is the first page, unless a file is asked for, and "d" goes from it to the first file.
         @view = OutlineView.new(first, workers:) if first
         path ? open_at(path, nil) : open_view(dashboard)

data/lib/raindown/tui/navigator/project_menu.rb

@@ -3,8 +3,8 @@
 module Raindown
   module TUI
     # The list of projects that drops down from the header's path, with "p" or a click, when there's more than one.
-    # Choosing one narrows the files and the dashboard to its own, and "All projects" shows every project's again.
-    # It stays open until a project's chosen, with Enter or a click, while up and down move its cursor.
+    # Choosing one narrows the files, the dashboard, Code feelings and Blueprints to its own, and "All projects" shows every
+    # project's again. It stays open until a project's chosen, with Enter or a click, while up and down move its cursor.
     # Esc or "p" close it without choosing, and other keys and clicks do nothing while it's open.
     module ProjectMenu
       # The menu's cursor, while it's open.
@@ -54,6 +54,8 @@ module Raindown
         @files.scope = project
         @endpoints.project = project
         dashboard.project = project
+        feelings.project = project
+        blueprints.project = project
         open_view(dashboard)
       end
     end

data/lib/raindown/tui/project.rb

@@ -65,7 +65,7 @@ module Raindown
       # 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)
+          lines = Utils.read_markdown(path).lines
           runnable = Document.read(path, bare: @bare).directives.select { it.endpoint? && it.writes }
           runnable.filter_map { |directive| endpoint(path, lines, directive) }
         rescue StandardError
@@ -94,7 +94,7 @@ module Raindown
       end
 
       def charts_in(path)
-        content = File.read(path, encoding: Encoding::UTF_8)
+        content = Utils.read_markdown(path)
         bare = @bare || BareDirectives.enabled?(path:, content:)
         lines = content.lines
         headings = Document.parse(content, bare:).headings

data/lib/raindown/tui/renderers/dashboard_renderer.rb

@@ -28,8 +28,10 @@ module Raindown
       def page = 'Dashboard'
 
       def lines
+        return alert(NO_PROJECTS) if navigator.projects.empty?
+
         cards = dashboard.cards
-        return blank(height, " No charts in #{File.basename(navigator.root)} yet, like <{ chart: '3 5 2 8' }>") if cards.empty?
+        return alert(["No charts in #{File.basename(navigator.root)} yet.", "Add one like <{ chart: '3 5 2 8' }>"]) if cards.empty?
 
         rows = dashboard.rows(width)
         @headings = headings(rows, cards)
@@ -94,9 +96,7 @@ module Raindown
         [segment(" #{from_home(project)}", :project)]
       end
 
-      def blank(count, message = '')
-        [[segment(message, :info)], *Array.new([count - 1, 0].max) { [segment('', :blank)] }].first(count)
-      end
+      def blank(count) = Array.new(count) { [segment('', :blank)] }
     end
   end
 end

data/lib/raindown/tui/renderers/renderer.rb

@@ -6,6 +6,9 @@ require_relative '../text'
 
 module Raindown
   module TUI
+    # Said in place of a page, like the charts or the code to feel, when the folder has no projects, with how to make one.
+    NO_PROJECTS = ['No projects found in this directory.', %(Run "raindown init" in a project's folder.)].freeze
+
     # Draws what's in a pane, :nav or :main, as lines of the pane's width and height, which the Layout puts in it.
     # Like the Layout, it's made again for each draw, so it draws what the Navigator and its view hold then.
     Renderer = Struct.new(:navigator, :pane, :width, :height) do
@@ -14,6 +17,23 @@ module Raindown
 
       # Its side of the line above the panes, which is blank unless it has something to say there, like a progress.
       def spacer = [segment('', :blank)]
+
+      # The lines in a purple box, like an alert, at the top left, with blank below it, like when there's nothing to show.
+      # It's no wider than the pane, cutting the lines to fit.
+      def alert(messages)
+        inner = [messages.map { display_width(it) }.max, width - 5].min.clamp(0..)
+        box = [alert_edge('╔', '╗', inner), *messages.map { alert_line(it, inner) }, alert_edge('╚', '╝', inner)]
+        (box + Array.new(height) { [segment('', :blank)] }).first(height)
+      end
+
+      def alert_edge(left, right, inner)
+        padded([segment('', :blank, width: 1), segment("#{left}#{'═' * (inner + 2)}#{right}", :alert, width: inner + 4)])
+      end
+
+      def alert_line(message, inner)
+        padded([segment('', :blank, width: 1), segment('║ ', :alert, width: 2), segment(message, :alert, width: inner),
+                segment(' ║', :alert, width: 2)])
+      end
     end
   end
 end

data/lib/raindown/tui/terminal/input.rb

@@ -34,7 +34,7 @@ module Raindown
         Curses.stdscr.timeout = timeout
         key = Curses.stdscr.getch
         return :tick if key.nil?
-        return mouse(zones) if key == Curses::KEY_MOUSE
+        return mouse(zones) if MOUSE && key == Curses::KEY_MOUSE
 
         Curses.stdscr.clear if key == Curses::KEY_RESIZE
         key_event(key, typing:)
@@ -60,22 +60,27 @@ module Raindown
         TYPING_KEYS.fetch(key) { Type.new(text: key) if key.is_a?(String) && key.match?(/\A[[:print:]]\z/) }
       end
 
+      # Windows' curses has no mouse, so the curses gem leaves out its constants and the mouse does nothing there.
+      MOUSE = Curses.respond_to?(:mousemask)
+
       # The mouse buttons that click, which are the left button's. Scrolling does nothing, and since older ncurses,
       # like macOS's, has no button for scrolling down, it can't be mistaken for a click.
-      CLICKS = Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED
+      CLICKS = MOUSE && Curses::BUTTON1_PRESSED | Curses::BUTTON1_CLICKED
 
       # Letting go of the button, which older ncurses, like macOS's, also reports for each move while it's held, as it
       # doesn't know the moves terminals send then.
-      RELEASE = Curses::BUTTON1_RELEASED
+      RELEASE = MOUSE && Curses::BUTTON1_RELEASED
 
       # Moving the mouse, which terminals report once they're asked to, with any motion tracking.
-      MOTION = Curses::REPORT_MOUSE_POSITION
+      MOTION = MOUSE && Curses::REPORT_MOUSE_POSITION
       ANY_MOTION = "\e[?1003h"
       NO_MOTION = "\e[?1003l"
 
       # The terminal sends the app its mouse events, clicks and moves, so scrolling doesn't scroll the terminal either.
       # ncurses only asks some terminals to report every move, so it's asked directly too, until untrack_mouse.
       def track_mouse
+        return unless MOUSE
+
         Curses.mousemask(CLICKS | RELEASE | MOTION)
         Curses.mouseinterval(0)
         $stdout.write(ANY_MOTION)
@@ -83,6 +88,8 @@ module Raindown
       end
 
       def untrack_mouse
+        return unless MOUSE
+
         $stdout.write(NO_MOTION)
         $stdout.flush
       end

data/lib/raindown/tui/terminal/styles.rb

@@ -85,7 +85,7 @@ module Raindown
           cursor: Curses::A_UNDERLINE, cursor_button: Curses::A_UNDERLINE | Curses::A_BOLD, heading: Curses::A_BOLD,
           body: Curses::A_DIM, error: Curses::A_BOLD, button: Curses::A_BOLD, folder: Curses::A_BOLD, project: Curses::A_BOLD, page: Curses::A_BOLD,
           key: Curses::A_REVERSE, border: Curses::A_DIM, divider: Curses::A_BOLD,
-          code_keyword: Curses::A_BOLD, code_comment: Curses::A_DIM
+          code_keyword: Curses::A_BOLD, code_comment: Curses::A_DIM, alert: Curses::A_BOLD
         )
       end
 
@@ -112,11 +112,12 @@ module Raindown
         Hash.new(text).merge(plain.transform_values { it | text })
       end
 
-      # Headings, the waffle's butter's shine and its syrup, and Code feelings' text and lines, bold around the method the
+      # Headings, alerts, the waffle's butter's shine and its syrup, and Code feelings' text and lines, bold around the method the
       # mouse is over, and its purple.
       def emphasis
         { heading: pair(:heading) | Curses::A_BOLD, feelings: pair(:feelings), nearby: pair(:feelings) | Curses::A_BOLD,
-          feelings_purple: pair(:feelings_purple), shine: pair(:shine) | Curses::A_BOLD, syrup: pair(:syrup) }
+          feelings_purple: pair(:feelings_purple), alert: pair(:feelings_purple) | Curses::A_BOLD,
+          shine: pair(:shine) | Curses::A_BOLD, syrup: pair(:syrup) }
       end
 
       # Highlighted code's tokens, like keywords and comments, with comments dim in 8 colours, where there's no grey.

data/lib/raindown/utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Raindown
+  module Utils
+    module_function
+
+    # A Markdown file's text, with its line endings as LF, "\n", whatever they are in the file.
+    #
+    # Windows ends lines with CRLF, "\r\n", and Git for Windows checks files out that way, so a file written or cloned on
+    # Windows can reach Raindown with them on any platform. Raindown finds directives, like a bare toc:, front matter
+    # and code fences line by line, with patterns that end at "\n", so a "\r" left at the end of a line stops them
+    # matching: toc: would be left as text instead of writing its table of contents.
+    #
+    # Text mode ("rt") reads CRLF as LF on every platform, as Ruby does on Windows by default, so the rest of Raindown
+    # only ever sees "\n". Writing a file back then gives it LF line endings, except on Windows, where text mode writes
+    # CRLF again.
+    def read_markdown(path)
+      File.read(path, mode: 'rt', encoding: Encoding::UTF_8)
+    end
+  end
+end

data/lib/raindown/workers/workers.rb

@@ -25,7 +25,7 @@ module Raindown
     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
+    def roots = @roots ||= Projects.roots(root).sort
 
     # A worker for each project, as they were found when the workers last started.
     def each(&)

data/lib/raindown.rb

@@ -15,6 +15,7 @@ require_relative 'raindown/heading_ids'
 require_relative 'raindown/node_blocks'
 require_relative 'raindown/pages'
 require_relative 'raindown/pre_renderer'
+require_relative 'raindown/utils'
 require_relative 'raindown/variables'
 
 module Raindown
@@ -40,7 +41,7 @@ module Raindown
   # 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)
+    render(markdown: Utils.read_markdown(path), metadata:, bare: bare || BareDirectives.file?(path), **options)
   end
 
   # Front matter keys are variables, like {title} or <{ title }>.

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.1
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-11-02 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -216,7 +216,10 @@ files:
 - lib/raindown/files.rb
 - lib/raindown/fragments.rb
 - lib/raindown/front_matter.rb
+- lib/raindown/gitignore.rb
 - lib/raindown/heading_ids.rb
+- lib/raindown/js/host.mjs
+- lib/raindown/js/js_nodes.rb
 - lib/raindown/node.rb
 - lib/raindown/node_blocks.rb
 - lib/raindown/node_injector.rb
@@ -295,6 +298,7 @@ files:
 - lib/raindown/tui/views/endpoint_view.rb
 - lib/raindown/tui/views/list_view.rb
 - lib/raindown/tui/views/outline_view.rb
+- lib/raindown/utils.rb
 - lib/raindown/variables.rb
 - lib/raindown/watcher/changes.rb
 - lib/raindown/watcher/file_watcher.rb