raindown 0.5.1 → 0.7.0

data/lib/raindown/tui/layout.rb

@@ -1,25 +1,37 @@
 # frozen_string_literal: true
 
-require 'unicode/display_width'
+require_relative 'events'
+require_relative 'text'
+require_relative 'title'
+require_relative 'menu_overlay'
+require_relative 'search_overlay'
 
 module Raindown
   module TUI
     # The screen as lines of styled segments, worked out from a Navigator with no terminal, so the Screen only paints them.
-    # A title, the files pane beside the outline, a status line and a bar of buttons:
-    #    raindown  docs  guides/setup.md
-    #    ▾ guides/       │ # Setup
-    #      setup.md      │   toc: [+3]
-    #    README.md       │   ## Install
-    #    Opened guides/setup.md
-    #    Tab Pane  Enter Open  x Run  e Edit  w Write back  r Reload  q Quit
+    # A Layout and its Renderers are the display code, made again for each draw: they lay out and render what the
+    # Navigator and its views hold. The Layout draws the title, the status and the buttons around two panes, nav and main,
+    # and a Renderer draws what's in each pane: the nav's ListRenderer, and the open view's renderer, an OutlineRenderer,
+    # DashboardRenderer or EndpointRenderer, which gives the buttons and page too:
+    #    ┌─ Layout ──────────────────────────────────────────────────┐
+    #    │  Raindown  ~/docs › guides/setup.md                       │
+    #    │ ┌─ nav pane ──────┐ ┌─ main pane ───────────────────────┐ │
+    #    │ │ Dashboard       ▏ # Setup                             │ │
+    #    │ │ ▾ guides/       ▏   toc: [+3]                         │ │
+    #    │ │   setup.md      ▏   ## Install                        │ │
+    #    │ └─ ListRenderer ──┘ └─ view.renderer ───────────────────┘ │
+    #    │  Opened guides/setup.md                                   │
+    #    │  Tab Pane  Enter Open  X Run  E dit  W rite back  Q uit   │
+    #    └───────────────────────────────────────────────────────────┘
     # Each line is exactly the width, in display columns. A segment with an event is clicked to send it.
     class Layout
-      Segment = Data.define(:text, :style, :event)
+      include Text
+      include Title
 
-      BUTTONS = [['Tab', 'Pane', :tab], ['Enter', 'Open', :enter], ['x', 'Run', :execute], ['e', 'Edit', :edit],
-                 ['w', 'Write back', :write_back], ['r', 'Reload', :reload], ['q', 'Quit', :quit]].freeze
-      FILES_WIDTH = (16..32)
-      INDENT = '  '
+      NAV_WIDTH = (16..32)
+      # The line between the nav and main panes, at its column's left edge, unlike │ in the middle,
+      # so a highlighted file's row runs up to it.
+      DIVIDER = '▏'
       # The title, status and button lines.
       CHROME_HEIGHT = 3
 
@@ -34,57 +46,49 @@ module Raindown
       def lines
         return [status].first(height) if height < CHROME_HEIGHT + 1
 
-        [title, *panes, status, button_bar]
+        overlaid([title, *panes, status, button_bar])
       end
 
-      def files_width
-        (width / 3).clamp(FILES_WIDTH.begin, [FILES_WIDTH.end, width / 2].min)
+      # A third of the width, within NAV_WIDTH, and never more than half of a narrow screen.
+      def nav_width
+        [(width / 3).clamp(NAV_WIDTH), width / 2].min
       end
 
       private
 
-      def title
-        path = navigator.path ? navigator.relative(navigator.path) : 'No Markdown files'
-        [segment(" raindown  #{File.basename(navigator.root)}  #{path}", :title)]
+      # The project menu or the search, drawn over the lines while it's open.
+      def overlaid(lines)
+        return MenuOverlay.new(navigator, width:, column: display_width(name)).apply(lines) if navigator.menu
+        return SearchOverlay.new(navigator, width:).apply(lines) if navigator.searching?
+
+        lines
       end
 
+      def body_height = height - CHROME_HEIGHT
+
+      # Below a blank line for spacing, the nav pane beside the main pane, each drawn by the renderer of what's in it.
       def panes
-        pane_height = height - CHROME_HEIGHT
-        files = navigator.visible(:files, pane_height)
-        outline = navigator.visible(:outline, pane_height)
+        nav = renderer_in(:nav, nav_width).lines
+        main = view_renderer.lines
 
-        Array.new(pane_height) do |index|
-          [*cell(:files, *files, index, files_width), Segment.new(text: '│', style: :border, event: nil),
-           *cell(:outline, *outline, index, width - files_width - 1)]
-        end
+        [spacer, *Array.new(body_height - 1) { |index| [*nav[index], divider(main[index]), *main[index]] }]
       end
 
-      # A pane's row as its text, then its buttons, or blank below its last row.
-      def cell(pane, rows, offset, index, cell_width)
-        row = rows[index]
-        return [segment('', :blank, width: cell_width)] unless row
+      # A line above the panes, for spacing, blank but for what the main pane's renderer puts in its side of it.
+      def spacer = [segment('', :blank, width: nav_width), divider([]), *view_renderer.spacer]
 
-        index += offset
-        selected = navigator.cursor(pane) == index
-        buttons = row_buttons(row, pane:, index:, selected:, cell_width:)
-        text_width = cell_width - display_width(buttons.map(&:text).join)
-        text = " #{INDENT * row.depth}#{row.text}"
-
-        [segment(text, row_style(pane, row, selected), width: text_width, event: [:select, pane, index]), *buttons]
+      # The divider is on the background of the outline's row beside it, when that's highlighted, so they meet.
+      def divider(main_line)
+        style = { selected: :selected_divider, cursor: :cursor_divider }.fetch(main_line.first&.style, :divider)
+        segment(DIVIDER, style, width: 1)
       end
 
-      # The row's buttons, right of its text, unless they'd take more than half the pane.
-      def row_buttons(row, pane:, index:, selected:, cell_width:)
-        buttons = row.buttons.map do |label, event|
-          Segment.new(text: " #{label}", style: selected ? :selected_button : :button, event: [:press, pane, index, event])
-        end
-        display_width(buttons.map(&:text).join) > cell_width / 2 ? [] : buttons
+      def view_renderer
+        @view_renderer ||= renderer_in(:main, width - nav_width - 1)
       end
 
-      def row_style(pane, row, selected)
-        return row.kind unless selected
-
-        navigator.focus == pane ? :selected : :cursor
+      def renderer_in(pane, width)
+        navigator.content(pane).renderer.new(navigator:, pane:, width:, height: body_height - 1)
       end
 
       def status
@@ -92,12 +96,20 @@ module Raindown
         [segment(" #{message}", kind)]
       end
 
+      # The first letter of a label is stylized as a keyboard key like "(E)dit".
+      def shown(key, label)
+        return [key, label] unless key.length == 1
+
+        [key.upcase, label.downcase.start_with?(key) ? label[1..] : label]
+      end
+
       # As many buttons as fit, each clicked by its key or its label.
       def button_bar
         segments = []
         used = 0
 
-        BUTTONS.each do |key, label, event|
+        view_renderer.buttons.each do |key, label, event|
+          key, label = shown(key, label)
           pair = [Segment.new(text: " #{key} ", style: :key, event:), Segment.new(text: "#{label} ", style: :bar, event:)]
           pair_width = display_width(pair.map(&:text).join)
           break if used + pair_width > width
@@ -108,35 +120,12 @@ module Raindown
 
         [*segments, segment('', :bar, width: width - used)]
       end
-
-      # Text cut or padded to the width, with a cut shown by an ellipsis.
-      def segment(text, style, width: self.width, event: nil)
-        Segment.new(text: fit(printable(text), width), style:, event:)
-      end
-
-      def fit(text, width)
-        return '' if width <= 0
-        return text + (' ' * (width - display_width(text))) if display_width(text) <= width
-
-        cut = +''
-        cut_width = 0
-        text.each_char do |char|
-          break if cut_width + display_width(char) > width - 1
-
-          cut << char
-          cut_width += display_width(char)
-        end
-        "#{cut}…#{' ' * (width - 1 - cut_width)}"
-      end
-
-      # Tabs and control characters, like in a directive's output, would move the terminal's cursor.
-      def printable(text)
-        text.gsub("\t", INDENT).gsub(/[[:cntrl:]]/, '')
-      end
-
-      def display_width(text)
-        Unicode::DisplayWidth.of(text)
-      end
     end
   end
 end
+
+require_relative 'renderers/list_renderer'
+require_relative 'renderers/outline_renderer'
+require_relative 'renderers/dashboard_renderer'
+require_relative 'renderers/endpoint_renderer'
+require_relative 'feelings/feelings_renderer'

data/lib/raindown/tui/menu_overlay.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'text'
+
+module Raindown
+  module TUI
+    # The project menu, drawn over the screen's lines in a box below the header's path:
+    #    🌧  Raindown  ~/dev ▾ › Dashboard
+    #                 ┌──────────────────────┐
+    #                 │ All projects       ✓ │
+    #                 │ ~/dev/raindown       │
+    #                 └──────────────────────┘
+    # Each item is clicked to choose it.
+    class MenuOverlay
+      include Text
+
+      def initialize(navigator, width:, column:)
+        @navigator = navigator
+        @width = width
+        @column = column
+      end
+
+      # The lines with the box drawn over them, from the line below the header.
+      def apply(lines)
+        box.each_with_index.map { |segments, offset| [offset + 1, segments] }.each do |row, segments|
+          lines[row] = overlay_segments(lines[row], segments, column: @column) if lines[row]
+        end
+        lines
+      end
+
+      private
+
+      def items
+        @navigator.menu_items.map { |project| project ? from_home(project) : 'All projects' }
+      end
+
+      def inner_width
+        [items.map { display_width(it) }.max + 4, @width - @column - 3].min
+      end
+
+      def box
+        top = segment("┌#{'─' * (inner_width + 2)}┐", :border)
+        bottom = segment("└#{'─' * (inner_width + 2)}┘", :border)
+        [[top], *items.each_with_index.map { |item, index| item_line(item, index) }, [bottom]]
+      end
+
+      def item_line(item, index)
+        chosen = @navigator.menu_items[index] == @navigator.project ? '✓' : ' '
+        style = @navigator.menu == index ? :selected : :menu
+        text = fit("#{fit(item, inner_width - 2)} #{chosen}", inner_width)
+        [segment('│ ', :border), segment(text, style, Click.new(pane: :menu, index:, action: :enter)), segment(' │', :border)]
+      end
+
+      def segment(text, style, event = nil)
+        Text::Segment.new(text:, style:, event:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative '../../actions'
+
+module Raindown
+  module TUI
+    # What a Navigator does to the open file: run an endpoint, open the editor, write back and read it again,
+    # and to a feeling about some code: draw the page it was noted down in, or ask Claude Code to fix the code.
+    # Each sets the status, so the Screen shows how it went, and returns what the Screen should do next, if anything.
+    module Commands
+      def run(file, line, name) = Wait.new(message: "Running #{name}...", task: -> { run_endpoint(file, line) })
+
+      # Opens the editor at the file's line, and writes the file back after it closes.
+      def edit_at(file, line)
+        @edited = file
+        Run.new(command: Actions.edit_command(file, line:))
+      end
+
+      def felt(feeling) = info("Felt #{feeling.temper} about #{feeling.method.label}")
+
+      # Leaves the screen for Claude Code, asked to fix the method, and the view reads the code again after.
+      def fix_with_agent(feeling)
+        return error('Install Claude Code, the claude command, to fix code with X') unless claude?
+
+        @edited = feeling.method.path
+        Run.new(command: ['claude', feeling.prompt])
+      end
+
+      private
+
+      def claude? = ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? { File.executable?(File.join(it, 'claude')) }
+
+      # Runs the endpoint selected in the outline, or listed below the files. One opened beside them runs itself.
+      def execute
+        target = selected&.target
+        return run(target.path, target.line, target.text) if target.is_a?(Endpoint)
+        return error('Select an endpoint to run') unless target.is_a?(Document::Directive) && target.endpoint?
+
+        run(path, target.line, "the endpoint on line #{target.line}")
+      end
+
+      def run_endpoint(file, line)
+        changed = @workers.for(file).call(:execute, file, line)
+        view.load
+        info(changed ? "Ran the endpoint on line #{line}" : 'The response is the same')
+      rescue StandardError => e
+        error(e.message)
+      end
+
+      # In the nav pane, the selected file opens at its top, and in the outline, the open file at the selected line.
+      def edit
+        row = selected
+        return error('Select a file to edit') if @focus == :nav && row&.kind != :file
+
+        return edit_at(row.target, 1) if @focus == :nav
+        return error('Open a file to edit') unless path
+
+        edit_at(path, row ? row.line : 1)
+      end
+
+      def write_back(file = path)
+        return error('Open a file to write back') unless file
+
+        changed = @workers.for(file).call(:write_back, file)
+        view.load
+        info(changed ? "Updated #{relative(file)}" : "#{relative(file)} is up to date")
+      rescue StandardError => e
+        error(e.message)
+      end
+
+      # The workers start again too, loading their projects' nodes again, like when one of them has changed.
+      def reload
+        @workers.restart
+        @files.load
+        @endpoints.load
+        view.load
+        info('Reloaded')
+      end
+
+      # Reads the file again when it's changed, like when it's saved in an editor or a watcher writes back to it.
+      def refresh
+        view.load if view.changed?
+        nil
+      end
+
+      def info(message)
+        @status = [:info, message]
+        nil
+      end
+
+      def error(message)
+        @status = [:error, message]
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # How a Navigator's focus and cursor move: Tab or left and right between the files and the view,
+    # and up and down in the pane with the focus.
+    module Focus
+      private
+
+      def other_pane
+        @focus == :nav ? :main : :nav
+      end
+
+      def move(by)
+        content(@focus).move(by)
+        nil
+      end
+
+      def switch(pane)
+        @focus = pane
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require_relative '../file_tree'
+require_relative 'commands'
+require_relative '../endpoints'
+require_relative 'focus'
+require_relative '../events'
+require_relative '../views/outline_view'
+require_relative '../views/list_view'
+require_relative 'project_menu'
+require_relative 'search'
+require_relative 'views'
+require_relative '../workers/workers'
+
+module Raindown
+  module TUI
+    # What the terminal UI shows and does, in plain Ruby, with no terminal: a FileTree of the project's Markdown files,
+    # beside the open file's Outline, or the Dashboard of its charts. The Screen draws it and sends it events, keys like
+    # :down, or a Click, and next_step returns what the Screen does next: nil to draw again, :quit to stop, or a Run or Wait.
+    class Navigator
+      include Commands
+      include Views
+      include ProjectMenu
+      include Search
+      include Focus
+
+      # Keys of the events that move the cursor or the focus, and those that act on what's selected.
+      MOVES = { up: -1, down: 1 }.freeze
+      PANES = { tab: nil, left: :nav, right: :main }.freeze
+      ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
+      # Keys that open the search, the project menu, the Dashboard or Code feelings, from anywhere.
+      OPENERS = { search: :open_search, projects: :toggle_menu, dashboard: :toggle_dashboard, feelings: :open_feelings }.freeze
+
+      attr_reader :focus, :status
+      # What the mouse is over, which a click there would send, like a Click on a method's cells, or nil.
+      attr_reader :hovered
+
+      def initialize(root:, path: nil, workers: Workers.new(root:))
+        @workers = workers
+        @files = FileTree.new(root:, workers:)
+        @endpoints = Endpoints.new(workers:)
+        @dashboard = DashboardView.new(root:, workers:)
+        @feelings = FeelingsView.new(root:)
+        @nav = ListView.new { nav_rows }
+        first = Projects.files(root, nested: true).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)
+      end
+
+      # An event nothing has, like a mouse button's release, does nothing.
+      def next_step(event)
+        case event
+        when nil then nil
+        when Click then click(event)
+        when Type then type(event)
+        when Hover then hover(event)
+        else route(event)
+        end
+      end
+
+      # After the editor closes, a Markdown file is written back, like a save while it's watched, and read again.
+      # Other files, like code that was felt, aren't written back, and the view reads them again.
+      def ran
+        write_back(@edited) if @files.files.include?(@edited)
+        view.load
+        @endpoints.load
+      end
+
+      def root = @files.root
+      def relative(path) = @files.relative(path)
+
+      # The folder the files are shown from: the chosen project's, or the root's.
+      def base = @files.base
+
+      # While the search, or the view, like a feeling's note, takes what's typed, rather than keys' events.
+      def typing? = searching? || view.typing?
+
+      # While the view wants drawing faster than the ticks, like Code feelings' rain.
+      def animating? = view.animating?
+
+      # What's in a pane: the nav's ListView on the left, or the view on the right, which keeps its own cursor.
+      def content(pane) = pane == :nav ? @nav : view
+
+      private
+
+      def hover(hover)
+        @hovered = hover.target
+        nil
+      end
+
+      # A typed character goes to the search, or to the view while it's typing.
+      def type(event)
+        return type_query(query + event.text) if searching?
+
+        view.next_step(event)&.take(self) if view.typing?
+      end
+
+      def route(name)
+        return :quit if name == :quit
+        return search_event(name) if searching?
+        return menu_event(name) if menu
+        return send(OPENERS[name]) if OPENERS.key?(name)
+        return view.next_step(name)&.take(self) if @focus == :main && view.next_step?(name)
+
+        browser_event(name)
+      end
+
+      # A click moves the cursor where it's clicked, and does the click's action there, like a key, unless that would
+      # leave the terminal UI, like for the editor, so a stray click only moves the cursor.
+      # While the project menu or the search is open, only its items are clicked.
+      def click(click)
+        return if menu && click.pane != :menu
+        return if searching? && click.pane != :search
+
+        point(click)
+        effect = route(click.action)
+        effect unless effect.is_a?(Run)
+      end
+
+      def point(click)
+        return @menu = click.index if click.pane == :menu
+        return @match = click.index if click.pane == :search
+
+        content(click.pane).cursor = click.index
+        @focus = click.pane
+      end
+
+      def browser_event(name)
+        return move(MOVES[name]) if MOVES.key?(name)
+        return switch(PANES[name] || other_pane) if PANES.key?(name)
+        return activate(name) if %i[enter toggle].include?(name)
+
+        send(ACTIONS[name]) if ACTIONS.key?(name)
+      end
+
+      # The Dashboard and Code feelings, whose emoji every terminal draws two columns wide, then the files and the
+      # endpoints, with a blank line between each section that has rows.
+      def nav_rows
+        pages = { '📊 Dashboard' => dashboard, '🎭 Feelings' => feelings }.map do |text, view|
+          Row.new(text:, depth: 0, kind: :page, target: view, open: OpenView.new(view:))
+        end
+        [pages, @files.rows, @endpoints.rows].reject(&:empty?).flat_map { [Row::SEPARATOR, *it] }.drop(1)
+      end
+
+      def selected
+        content(@focus).selected
+      end
+
+      # Enter opens what's selected, or folds it, and Space only folds.
+      def activate(name)
+        row = selected
+        return row.open.take(self) if name == :enter && row&.open
+
+        row&.fold&.call
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+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.
+    # 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.
+      attr_reader :menu
+
+      # The project the files and the dashboard are narrowed to, or nil for every project.
+      attr_reader :project
+
+      def projects = @workers.roots
+
+      # The menu's items: nil for all the projects, then each project's root.
+      def menu_items = [nil, *projects]
+
+      def projects? = projects.length > 1
+
+      private
+
+      def toggle_menu
+        return info("There's one project here") unless projects?
+
+        @menu = @menu ? nil : menu_items.index(project) || 0
+        nil
+      end
+
+      def menu_event(name)
+        case name
+        when :up, :down then move_menu(name == :up ? -1 : 1)
+        when :enter then choose(menu_items[@menu])
+        when :escape, :projects then close_menu
+        end
+      end
+
+      def move_menu(by)
+        @menu = (@menu + by).clamp(0, menu_items.length - 1)
+        nil
+      end
+
+      def close_menu
+        @menu = nil
+        nil
+      end
+
+      # Shows the project's dashboard, or every project's.
+      def choose(project)
+        @menu = nil
+        @project = project
+        @files.scope = project
+        @endpoints.project = project
+        dashboard.project = project
+        open_view(dashboard)
+      end
+    end
+  end
+end