raindown 0.6.0 → 0.7.0

data/lib/raindown/tui/row.rb

@@ -5,8 +5,10 @@ module Raindown
     # A line of a pane. Target is what it's about: a folder or file path, a Heading or Directive, or a line number.
     # Buttons are [label, event] pairs, like ['[Run]', :execute], and a tag is an Endpoint, whose method is before its text.
     # Open is the Navigator's next step on Enter, like an Open of a file, and fold, a block that folds or expands the row.
-    Row = Data.define(:text, :depth, :kind, :target, :buttons, :tag, :open, :fold) do
-      def initialize(buttons: [], tag: nil, open: nil, fold: nil, **) = super
+    # Code is the text highlighted, as [text, style] parts, for a line of code, like a directive's body.
+    # Each optional field has a default, which is why initialize takes so many.
+    Row = Data.define(:text, :depth, :kind, :target, :buttons, :tag, :open, :fold, :code) do
+      def initialize(buttons: [], tag: nil, open: nil, fold: nil, code: nil, **) = super # rubocop:disable Metrics/ParameterLists
 
       # A separator is space between a pane's sections, which the cursor skips and clicks don't reach.
       def selectable? = kind != :separator

data/lib/raindown/tui/rows.rb

@@ -29,9 +29,10 @@ module Raindown
         parts.zip(spread(parts.map(&:first), width)).map { |(text, style), part| segment(text, style, width: part, event:) }
       end
 
-      # The row's text, after its tag in the tag's style, unless the row's selected.
+      # The row's text, after its tag in the tag's style, or highlighted when it's code, unless the row's selected.
       def row_parts(row, style, selected)
         lead = " #{Text::INDENT * row.depth}"
+        return [[lead, style], *row.code] if row.code && !selected
         return [["#{lead}#{row.text}", style]] unless row.tag
 
         [["#{lead}#{row.tag.method} ", selected ? style : row.tag.style], [row.text, style]]

data/lib/raindown/tui/search_overlay.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'events'
+require_relative 'text'
+
+module Raindown
+  module TUI
+    # The search, drawn over the screen's lines in a box below the title: what's typed, then the places that match it,
+    # each with where it is, and the selected one highlighted:
+    #    ┌─ Teleport ───────────────────────────────┐
+    #    │ / stp▏                                   │
+    #    │ ## Setup               guides/setup.md:3 │
+    #    │ ## Steps                     notes.md:12 │
+    #    └──────────────────────────────────────────┘
+    # Each place is clicked to open it.
+    class SearchOverlay
+      include Text
+
+      # The widest the box is, with its border.
+      MAX_WIDTH = 72
+
+      def initialize(navigator, width:)
+        @navigator = navigator
+        @box_width = [width - 4, MAX_WIDTH].min
+        @column = (width - @box_width) / 2
+      end
+
+      # The lines with the box drawn over them, from the line below the title.
+      def apply(lines)
+        box.each_with_index do |segments, offset|
+          row = offset + 1
+          lines[row] = overlay_segments(lines[row], segments, column: @column) if lines[row]
+        end
+        lines
+      end
+
+      private
+
+      # The columns inside the border, "│ " and " │".
+      def inner = @box_width - 4
+
+      def box
+        [edge('┌─ Teleport ', '┐'), boxed(segment("/ #{@navigator.query}▏", :menu, width: inner)), *results, edge('└', '┘')]
+      end
+
+      def results
+        matches = @navigator.matches
+        return [boxed(segment('No matches', :info, width: inner))] if matches.empty?
+
+        matches.each_with_index.map { |place, index| place_line(place, index) }
+      end
+
+      # The place's text, then where it is, on the right, both highlighted when it's selected.
+      def place_line(place, index)
+        text_style = :menu
+        where_style = :body
+        text_style = where_style = :selected if @navigator.match == index
+        event = Click.new(pane: :search, index:, action: :enter)
+        where = " #{place.where}"
+        where_width = [display_width(where), inner / 2].min
+
+        boxed(segment(place.text, text_style, width: inner - where_width, event:),
+              segment(where, where_style, width: where_width, event:))
+      end
+
+      def boxed(*segments) = [segment('│ ', :border, width: 2), *segments, segment(' │', :border, width: 2)]
+
+      def edge(left, right)
+        [segment("#{left}#{'─' * (@box_width - display_width(left) - 1)}#{right}", :border, width: @box_width)]
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 require 'curses'
 require 'unicode/display_width'
 
+require_relative '../events'
+
 module Raindown
   module TUI
     # Turns curses' keys and clicks into a Navigator's events.
@@ -12,25 +14,60 @@ module Raindown
         Curses::KEY_LEFT => :left, 'h' => :left, Curses::KEY_RIGHT => :right, 'l' => :right,
         "\t" => :tab, Curses::KEY_BTAB => :tab, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
         ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'd' => :dashboard,
-        'p' => :projects, "\e" => :escape, 'q' => :quit
+        'p' => :projects, 'f' => :feelings, "\x14" => :celebrate, '/' => :search,
+        '1' => :bin1, '2' => :bin2, '3' => :bin3, '4' => :bin4, '5' => :bin5, '6' => :bin6, "\e" => :escape, 'q' => :quit
+      }.freeze
+      # While typing, like in the search, printable characters are typed, and only these keys do anything else.
+      TYPING_KEYS = {
+        Curses::KEY_UP => :up, Curses::KEY_DOWN => :down, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
+        "\e" => :escape, Curses::KEY_BACKSPACE => :backspace, "\x7F" => :backspace, "\b" => :backspace
       }.freeze
 
       module_function
 
       # A key from getch, which is a string for a printable character and otherwise a number.
-      # Letters are the same with Shift, as the buttons show them as capitals.
-      def key_event(key)
+      # Letters are the same with Shift, as the buttons show them as capitals, unless they're being typed.
+      def key_event(key, typing: false)
+        return typing_event(key) if typing
+
         key = key.chr if key.is_a?(Integer) && key < 256
         KEYS[key.is_a?(String) ? key.downcase : key]
       end
 
+      def typing_event(key)
+        key = key.chr if key.is_a?(Integer) && key < 256
+        TYPING_KEYS.fetch(key) { Type.new(text: key) if key.is_a?(String) && key.match?(/\A[[:print:]]\z/) }
+      end
+
       # 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
 
-      # A click sends the event of what's under it.
+      # Moving the mouse, which terminals report once they're asked to, with any motion tracking.
+      MOTION = 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
+        Curses.mousemask(CLICKS | MOTION)
+        Curses.mouseinterval(0)
+        $stdout.write(ANY_MOTION)
+        $stdout.flush
+      end
+
+      def untrack_mouse
+        $stdout.write(NO_MOTION)
+        $stdout.flush
+      end
+
+      # A click sends the event of what's under it, and moving the mouse a Hover of it.
       def mouse_event(event, zones)
-        click(zones, column: event.x, row: event.y) if event.bstate.anybits?(CLICKS)
+        target = click(zones, column: event.x, row: event.y)
+        return target if event.bstate.anybits?(CLICKS)
+
+        Hover.new(target:) if event.bstate.anybits?(MOTION)
       end
 
       # Where each of a Layout's segments with an event is on the screen, as [row, columns, event].

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

@@ -13,8 +13,9 @@ module Raindown
     # Paints a Navigator's Layout with curses, and sends the Navigator the events of keys and clicks, read with Input.
     # Only this class draws on the terminal, so another library could draw the same Layout.
     class Screen
-      # How often, in milliseconds, the open file is checked for changes while no key is pressed.
-      TICK = 500
+      # How often, in milliseconds, the open file is checked for changes while no key is pressed, or, while the view
+      # animates, like Code feelings' rain, it's drawn.
+      TICKS = { false => 500, true => 60 }.freeze
 
       def initialize(navigator)
         @navigator = navigator
@@ -61,13 +62,11 @@ module Raindown
         Curses.nonl
         Curses.curs_set(0)
         Curses.stdscr.keypad(true)
-        Curses.stdscr.timeout = TICK
-        # The terminal sends the app its mouse events, so scrolling doesn't scroll the terminal either.
-        Curses.mousemask(Input::CLICKS)
-        Curses.mouseinterval(0)
+        Input.track_mouse
       end
 
       def stop
+        Input.untrack_mouse
         Curses.close_screen
       end
 
@@ -98,7 +97,7 @@ module Raindown
       end
 
       def paint(window, segment)
-        window.attron(@styles.fetch(segment.style, Curses::A_NORMAL)) { window.addstr(segment.text) }
+        window.attron(@styles[segment.style]) { window.addstr(segment.text) }
       end
 
       def last_line(segments)
@@ -108,12 +107,13 @@ module Raindown
 
       # The next event, or :tick when no key is pressed in time, or nil for keys without one, like a resize.
       def read
+        Curses.stdscr.timeout = TICKS.fetch(@navigator.animating?)
         key = Curses.stdscr.getch
         return :tick if key.nil?
         return mouse if key == Curses::KEY_MOUSE
 
         Curses.stdscr.clear if key == Curses::KEY_RESIZE
-        Input.key_event(key)
+        Input.key_event(key, typing: @navigator.typing?)
       end
 
       # The curses gem warns the first time it makes a MouseEvent, that it's "undefining the allocator" of the class.
@@ -131,13 +131,16 @@ module Raindown
         window.refresh
       end
 
-      # Leaves the screen to the command, like the editor, and comes back to it after.
+      # Leaves the screen to the command, like the editor, and comes back to it after. The command isn't sent the
+      # mouse's moves meanwhile.
       def suspend
         Curses.def_prog_mode
+        Input.untrack_mouse
         Curses.close_screen
         yield
       ensure
         Curses.reset_prog_mode
+        Input.track_mouse
         Curses.stdscr.clear
         Curses.refresh
       end

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

@@ -4,22 +4,47 @@ require 'curses'
 
 module Raindown
   module TUI
-    # The curses attributes of a Layout's styles. The title is white on blue, and the selected row white on a lighter
-    # blue, or on dark grey in the panes without the focus, while other colours are on the terminal's own background.
+    # The curses attributes of a Layout's styles. Text is periwinkle where there are 256 colours, and the terminal's own
+    # colour otherwise, like the line between the panes, while the title and headings are cornflower blue. The selected
+    # row is white on blue, or on dark grey in the panes without the focus, while other colours are on the terminal's own
+    # background.
     # With only 8 colours, there's no dark grey, so those rows are underlined, and without colours,
     # the rest are in reverse.
     module Styles
-      COLORS = { directive: Curses::COLOR_CYAN, button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED,
-                 folder: Curses::COLOR_BLUE }.freeze
+      COLORS = { button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED }.freeze
+      # Directives, like charts' on the Dashboard, in purple, and the folders, projects and pages in the files, the title,
+      # and headings, like the outline's and the Dashboard cards', in cornflower blue, from the 256 colours most terminals
+      # have, or magenta and blue with 8.
+      ACCENTS = { directive: 141, folder: 111, title: 111, heading: 111 }.freeze
+      BASIC_ACCENTS = { directive: Curses::COLOR_MAGENTA, folder: Curses::COLOR_BLUE, title: Curses::COLOR_BLUE,
+                        heading: Curses::COLOR_BLUE }.freeze
       # The colours of endpoints' HTTP methods, like GET in green, from the 256 colours most terminals have,
       # which are the same in every theme, unlike the 8 they all do, where green can look yellow.
       METHODS = { get: 40, post: 33, delete: 196, put: 220, patch: 171, head: 44, options: 44 }.freeze
       BASIC_METHODS = { get: Curses::COLOR_GREEN, post: Curses::COLOR_BLUE, delete: Curses::COLOR_RED,
                         put: Curses::COLOR_YELLOW, patch: Curses::COLOR_MAGENTA, head: Curses::COLOR_CYAN,
                         options: Curses::COLOR_CYAN }.freeze
-      # The title's and the selected row's blues, from the 256 colours most terminals have, or the 8 they all do.
-      BLUES = { title: 25, selected: 33 }.freeze
-      BASIC_BLUES = { title: Curses::COLOR_BLUE, selected: Curses::COLOR_CYAN }.freeze
+      # Highlighted code's colours, by the kind of token, from the 256 colours most terminals have, or the 8 they all do,
+      # where comments are dim instead of grey.
+      CODE = { code_keyword: 204, code_string: 114, code_number: 179, code_function: 75, code_constant: 117,
+               code_comment: 244 }.freeze
+      BASIC_CODE = { code_keyword: Curses::COLOR_MAGENTA, code_string: Curses::COLOR_GREEN, code_number: Curses::COLOR_YELLOW,
+                     code_function: Curses::COLOR_BLUE, code_constant: Curses::COLOR_CYAN, code_comment: Curses::COLOR_WHITE }.freeze
+      # Code feelings' bright colours, for its rain and fireworks, from the 256 colours most terminals have, or
+      # the 8 they all do.
+      BRIGHT = { bright_red: 203, bright_orange: 215, bright_yellow: 227, bright_green: 120, bright_cyan: 87,
+                 bright_blue: 75, bright_purple: 177, bright_pink: 213 }.freeze
+      BASIC_BRIGHT = { bright_red: Curses::COLOR_RED, bright_orange: Curses::COLOR_YELLOW, bright_yellow: Curses::COLOR_YELLOW,
+                       bright_green: Curses::COLOR_GREEN, bright_cyan: Curses::COLOR_CYAN, bright_blue: Curses::COLOR_BLUE,
+                       bright_purple: Curses::COLOR_MAGENTA, bright_pink: Curses::COLOR_MAGENTA }.freeze
+      # The selected row's blue, from the 256 colours most terminals have, or the 8 they all do.
+      BLUES = { selected: 33 }.freeze
+      BASIC_BLUES = { selected: Curses::COLOR_CYAN }.freeze
+      # Text that has no colour of its own, from the 256 colours most terminals have, or the terminal's own with 8.
+      PERIWINKLE = 147
+      # Code feelings' text and lines, the Dashboard cards' charts, and code blocks, in lavender, or magenta in 8 colours.
+      FEELINGS = { feelings: 183 }.freeze
+      BASIC_FEELINGS = { feelings: Curses::COLOR_MAGENTA }.freeze
       BRIGHT_WHITE = 15
       DARK_GREY = 238
 
@@ -33,26 +58,57 @@ module Raindown
         colored
       end
 
+      # Without colours, a style that isn't here is the terminal's own.
       def plain
-        { title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, selected_button: Curses::A_REVERSE,
+        Hash.new(Curses::A_NORMAL).merge(
+          title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, selected_button: Curses::A_REVERSE,
           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, dashboard: Curses::A_BOLD,
-          key: Curses::A_REVERSE, border: Curses::A_DIM, run: Curses::A_REVERSE | Curses::A_BOLD, divider: Curses::A_BOLD,
-          selected_divider: Curses::A_REVERSE, cursor_divider: 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,
+          selected_divider: Curses::A_REVERSE, cursor_divider: Curses::A_BOLD,
+          code_keyword: Curses::A_BOLD, code_comment: Curses::A_DIM
+        )
       end
 
       def colored
-        plain.merge(
+        in_text_color.merge(
           title: pair(:title) | Curses::A_BOLD, selected: pair(:selected) | white_bold,
           selected_button: pair(:selected_button) | Curses::A_BOLD, directive: pair(:directive),
-          error: pair(:error) | Curses::A_BOLD, button: pair(:button) | Curses::A_BOLD, divider: pair(:divider),
-          selected_divider: pair(:selected_divider), run: pair(:run) | Curses::A_BOLD, **files, **unfocused
+          error: pair(:error) | Curses::A_BOLD, button: pair(:button) | Curses::A_BOLD, **emphasis,
+          **dividers, **code_tokens, **bright, **files, **unfocused
         )
       end
 
+      # The styles without a colour of their own, or that are only bold, dim or the like, in the text's colour, which is
+      # also any style that isn't here.
+      def in_text_color
+        text = pair(:text)
+        Hash.new(text).merge(plain.transform_values { it | text })
+      end
+
+      # Headings, and Code feelings' text and lines, whose lavender the Dashboard cards' charts and code
+      # blocks are too, apart from highlighted code's keywords, strings and the like.
+      def emphasis
+        lavender = pair(:feelings)
+        { heading: pair(:heading) | Curses::A_BOLD, feelings: lavender, chart: lavender, code: lavender }
+      end
+
+      # Highlighted code's tokens, like keywords and comments, with comments dim in 8 colours, where there's no grey.
+      def code_tokens
+        tokens = CODE.keys.to_h { [it, pair(it)] }
+        tokens[:code_comment] |= Curses::A_DIM if Curses.colors < 256
+        tokens
+      end
+
+      # The bright colours, bold, so they're bright in 8 colours too.
+      def bright = BRIGHT.keys.to_h { [it, pair(it) | Curses::A_BOLD] }
+
+      # The line between the panes, and where it meets a selected row.
+      def dividers = { divider: pair(:divider), selected_divider: pair(:selected_divider) }
+
       def files
-        { folder: pair(:folder) | Curses::A_BOLD, project: pair(:directive) | Curses::A_BOLD,
-          dashboard: pair(:directive) | Curses::A_BOLD, **METHODS.keys.to_h { [:"method_#{it}", pair(:"method_#{it}") | Curses::A_BOLD] } }
+        { folder: pair(:folder) | Curses::A_BOLD, project: pair(:folder) | Curses::A_BOLD,
+          page: pair(:folder) | Curses::A_BOLD, **METHODS.keys.to_h { [:"method_#{it}", pair(:"method_#{it}") | Curses::A_BOLD] } }
       end
 
       # The selected rows of the panes without the focus, on dark grey where there's one.
@@ -67,14 +123,16 @@ module Raindown
         many = Curses.colors >= 256
         blues = many ? BLUES : BASIC_BLUES
         white = many ? BRIGHT_WHITE : Curses::COLOR_WHITE
+        text = many ? PERIWINKLE : -1
 
         [*COLORS.map { |name, color| [name, color, -1] },
          *(many ? METHODS : BASIC_METHODS).map { |name, color| [:"method_#{name}", color, -1] },
-         [:title, white, blues[:title]],
+         *(many ? CODE.merge(BRIGHT, FEELINGS, ACCENTS) : BASIC_CODE.merge(BASIC_BRIGHT, BASIC_FEELINGS, BASIC_ACCENTS))
+           .map { |name, color| [name, color, -1] },
+         [:text, text, -1],
          [:selected, white, blues[:selected]], [:selected_button, Curses::COLOR_YELLOW, blues[:selected]],
-         [:cursor, white, DARK_GREY], [:cursor_button, Curses::COLOR_YELLOW, DARK_GREY], [:divider, blues[:title], -1],
-         [:selected_divider, blues[:title], blues[:selected]], [:cursor_divider, blues[:title], DARK_GREY],
-         [:run, white, Curses::COLOR_GREEN]]
+         [:cursor, white, DARK_GREY], [:cursor_button, Curses::COLOR_YELLOW, DARK_GREY], [:divider, text, -1],
+         [:selected_divider, text, blues[:selected]], [:cursor_divider, text, DARK_GREY]]
       end
 
       def pair(name)

data/lib/raindown/tui/text.rb

@@ -50,6 +50,33 @@ 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) }

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 animating? = false
 
       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.

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

@@ -26,6 +26,8 @@ module Raindown
       def path = endpoint.path
       def status(_navigator) = [:info, endpoint.text]
       def changed? = false
+      def typing? = false
+      def animating? = false
       def next_step?(key) = %i[up down enter edit execute].include?(key)
 
       # Clicks on the response only move the focus to it.

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

@@ -13,6 +13,8 @@ module Raindown
       end
 
       def renderer = ListRenderer
+      def typing? = false
+      def animating? = false
 
       def rows = @rows.call
       def selected = rows[cursor]

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

@@ -3,6 +3,7 @@
 require_relative '../../document'
 require_relative '../events'
 require_relative 'list_view'
+require_relative '../highlighter'
 require_relative '../row'
 require_relative '../workers/worker'
 
@@ -34,6 +35,7 @@ module Raindown
         @lines = outline.lines
         @headings = outline.headings
         @directives = outline.directives
+        @highlighted = {}
         @error = nil
       rescue Worker::Error, SystemCallError => e
         @error = e.message
@@ -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) } }

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

@@ -9,6 +9,7 @@ require_relative '../../node_blocks'
 require_relative '../../nodes'
 require_relative '../../pages'
 require_relative '../../projects'
+require_relative '../../stat'
 require_relative '../card'
 require_relative '../endpoint'
 require_relative '../../code_blocks'
@@ -39,7 +40,8 @@ module Raindown
         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.
+      # Every chart and stat in the project's files, or any node that draws a card, 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?
@@ -87,7 +89,7 @@ module Raindown
         headings = Document.parse(content, bare:).headings
 
         NodeBlocks.find(lines, front_matter: FrontMatter.parse(content).first, bare:)
-                  .select { |block| block[:node].is_a?(Raindown::Chart) }
+                  .select { it[:node].respond_to?(:card_lines) }
                   .map { |block| chart(block, path:, lines:, headings:) }
       rescue StandardError => e
         @file_errors << "#{path.delete_prefix(File.join(root, ''))}: #{e.message}"
@@ -109,11 +111,9 @@ module Raindown
         { 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.
+      # Draws the chart or stat 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)
+        chart[:node].card_lines(metadata:)
       rescue StandardError => e
         ["Can't chart: #{e.message}"]
       end

data/lib/raindown/tui.rb

@@ -22,6 +22,8 @@ module Raindown
       # so two projects' nodes of the same name stay apart.
       workers = Workers.new(root:)
 
+      # Rouge loads here, rather than with Raindown, which doesn't highlight code outside the TUI.
+      require 'rouge'
       Screen.new(Navigator.new(root:, path: (path unless File.directory?(path)), workers:)).run
     ensure
       workers&.stop

data/lib/version.rb

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