raindown 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e35dfde9371c5f805bff304124c0abe22ca89254f14c5c70d2996e14d0dbb0f
-  data.tar.gz: 76774aa6b06fec8b50e0929b9ac86259511fb1ab9417ce48fcfa56afd20c90cf
+  metadata.gz: c9a61e7a842dcd5dc4cc5f6d004db388173ef2d5c48af1a50e32fea6c317b678
+  data.tar.gz: 7bbae724e020d48a3f095ba1cc8e1c45b9ee5dd483daf0af5f8edd4333d83205
 SHA512:
-  metadata.gz: 454c35bfd6c74cc2c125d8229ffe971cb178fb40f4d87affad0fc5d345301fd4d5a0e32a15852f05eb35231e0054b2a5b55ff2a4eb7253cc85aef17f4d17e178
-  data.tar.gz: 33b41ed491f7cc8238f3c3d99b2d72e2b0197dce29146dd14bdc704dd0ea6fa64788c97ed5d60bda60ef4602e9e6dedb2d22b02a1f8886a5c4592a522d96886e
+  metadata.gz: b8f312582ede3900be43490c52c54ce3df6292764c04c177f54510e397a4814c9a9184cbb0710113055bb0dd140f00ced0bcf309f59583d34485a900579ac64b
+  data.tar.gz: 932d51981cd38660a402a40bbf9b0015da35baf62bad04152cdfdc262287f9593643daf66d2b60b6282e4df8a3de553a9ebba1793b37bec0972c145ea275c5a0

data/lib/raindown/cli.rb

@@ -23,8 +23,8 @@ module Raindown
 
       Commands:
         init [DIRECTORY]    Create a .raindown folder for the project's config and nodes (default: current directory)
-        tui [PATH]          Browse a project's files and outlines in the terminal, fold directives, run endpoints
-                            and open the editor at a line
+        tui [PATH]          Browse a project's files and outlines in the terminal, fold directives, run endpoints,
+                            open the editor at a line and see a dashboard of the project's charts
 
       Options:
         --html [OUTPUT]     Render FILE to HTML once, writing to OUTPUT or else printing to stdout

data/lib/raindown/document.rb

@@ -2,6 +2,7 @@
 
 require 'commonmarker'
 
+require_relative '../raindown'
 require_relative 'bare_directives'
 require_relative 'code_blocks'
 require_relative 'endpoint/endpoint_runner'
@@ -17,9 +18,10 @@ module Raindown
 
     # A content directive: a node, like toc: or a project's Changelog:, or an endpoint.
     # It spans line to end_line, its end tag, or the last line of a bare block.
+    # Body is the lines inside it, between it and its end tag, like an endpoint's request and response.
     # Output is the lines Raindown writes back, like a node's Markdown or an endpoint's response, and is nil
     # when nothing's written yet. A self-closing directive like <{ :toc }> only renders, so it never writes.
-    Directive = Data.define(:name, :args, :line, :end_line, :output, :writes) do
+    Directive = Data.define(:name, :args, :line, :end_line, :body, :output, :writes) do
       def endpoint? = name == 'endpoint'
     end
 
@@ -27,6 +29,7 @@ module Raindown
     TEXT_NODES = %i[text code].freeze
     BREAK_NODES = %i[softbreak linebreak].freeze
     ENDPOINT_END_TAG = /\A {0,3}<\{\s*:endpoint\s*\}>[ \t]*$/
+    END_TAG = /\A {0,3}<\{\s*:[\w:]+\s*\}>[ \t]*$/
 
     def self.parse(markdown, bare: false)
       new(markdown:, bare:)
@@ -139,10 +142,18 @@ module Raindown
       first..last if first <= last
     end
 
-    # From a range of indexes to line numbers.
+    # From a range of indexes to line numbers. The body is the lines after the directive, up to its end tag,
+    # or to the end of a bare block, which has none.
     def directive(name, args, span, output:, writes:)
-      output = (output.begin + 1)..(output.end + 1) if output
-      Directive.new(name:, args:, line: span.begin + 1, end_line: span.end + 1, output:, writes:)
+      end_tag = span.end > span.begin && @lines[span.end].match?(END_TAG)
+      body = trimmed(span.begin + 1, end_tag ? span.end - 1 : span.end)
+
+      Directive.new(name:, args:, line: span.begin + 1, end_line: span.end + 1, body: lines(body), output: lines(output),
+                    writes:)
+    end
+
+    def lines(range)
+      (range.begin + 1)..(range.end + 1) if range
     end
   end
 end

data/lib/raindown/endpoint/curl.rb

@@ -10,6 +10,7 @@ module Raindown
   # are allowed: nothing that reads or writes local files, loads a config, or uses another protocol.
   module Curl
     class Error < StandardError; end
+    Request = Data.define(:method, :url)
 
     TIMEOUT = '30'
     # --disable must come first and skips ~/.curlrc. The protocol options stop redirects to file:// and the like.
@@ -64,6 +65,20 @@ module Raindown
       raise Error, 'curl is not installed'
     end
 
+    # The snippet's method and URL, like GET https://httpbin.org/uuid, or nil when it can't be read.
+    # A snippet that sends data is a POST, unless it says otherwise, as with curl.
+    def request(snippet)
+      args = arguments(snippet)
+      url = args.find { it.match?(URL) }
+      method = args[args.index('--request') + 1] if args.include?('--request')
+      method ||= 'HEAD' if args.include?('--head')
+      method ||= 'POST' if args.intersect?(VALUE_CHECKS.keys.grep(/data|json/))
+
+      Request.new(method: (method || 'GET').upcase, url:) if url
+    rescue Error
+      nil
+    end
+
     def arguments(snippet)
       words = Shellwords.split(snippet.gsub(/\\\r?\n/, ' ').strip.delete_prefix('$ '))
       raise Error, 'Endpoint snippets must start with curl' unless words.first == 'curl'

data/lib/raindown/projects.rb

@@ -35,14 +35,14 @@ module Raindown
       folder && File.dirname(folder)
     end
 
-    # The project's Markdown files, sorted. Ignored folders and the projects inside it are left out,
-    # since those projects have nodes of their own.
-    def files(root)
+    # 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)
       files = []
 
       Find.find(root) do |path|
         if File.directory?(path)
-          Find.prune if path != root && (ignored?(File.basename(path)) || File.directory?(File.join(path, Nodes::FOLDER)))
+          Find.prune if path != root && (ignored?(File.basename(path)) || (!nested && project?(path)))
         elsif markdown?(path, root:)
           files << path
         end
@@ -64,6 +64,10 @@ module Raindown
       File.expand_path(path).start_with?(File.join(root, Nodes::FOLDER, '')) && %w[.rb .rbx].include?(File.extname(path))
     end
 
+    def project?(folder)
+      File.directory?(File.join(folder, Nodes::FOLDER))
+    end
+
     def ignored?(folder)
       folder.start_with?('.') || IGNORED.include?(folder)
     end

data/lib/raindown/tui/card.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+module Raindown
+  module TUI
+    # A chart on the dashboard, drawn from its data by its project's Worker: a title of its file, from its project,
+    # and the heading above it, then its directive, then the chart, each line with its Layout style,
+    # in a border with rounded corners. It's as wide as the chart, so the title and directive are cut to fit it:
+    #    ╭───────────────────────────────────────╮
+    #    │ markdown.md › Charts                  │
+    #    │ chart: 'data/downloads.csv' width: 30 │
+    #    │ Jun  ██████▊                   640    │
+    #    ╰───────────────────────────────────────╯
+    class Card < Data.define(:project, :path, :line, :heading, :directive, :chart)
+      # The border's columns either side of a card's lines, "│ " and " │", and its lines above and below them.
+      BORDER_WIDTH = 4
+      BORDER_HEIGHT = 2
+
+      def title = [path.delete_prefix(File.join(project, '')), heading].compact.join(' › ')
+
+      def lines = parts.map(&:first)
+
+      # Each line, with its style.
+      def parts = [[title, :heading], [directive, :directive], *chart.map { [it, :chart] }]
+
+      # As wide as its chart.
+      def width = chart.map { Unicode::DisplayWidth.of(it) }.max || 0
+
+      def height = lines.length
+
+      # With its border, within a range of widths, like a pane's.
+      def box_width(within: nil) = within ? (width + BORDER_WIDTH).clamp(within) : width + BORDER_WIDTH
+      def box_height = height + BORDER_HEIGHT
+
+      # A line of the card in its border, as [text, style, width] parts, for a card the box width wide.
+      # The border's top is line 0, and below its bottom, the lines are blank, for a card shorter than its row.
+      # The title's style is title_style, like when the card's selected.
+      def format_line(line, box_width:, title_style: :heading)
+        width = [box_width - BORDER_WIDTH, 0].max
+        return [border(width, '╭', '╮')] if line.zero?
+        return [border(width, '╰', '╯')] if line == height + 1
+        return [['', :blank, width + BORDER_WIDTH]] if line > height + 1
+
+        text, style = parts[line - 1]
+        [['│ ', :border, 2], [text, style == :heading ? title_style : style, width], [' │', :border, 2]]
+      end
+
+      private
+
+      def border(width, left, right)
+        ["#{left}#{'─' * (width + 2)}#{right}", :border, width + BORDER_WIDTH]
+      end
+    end
+  end
+end

data/lib/raindown/tui/endpoint.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # An endpoint in a project's files, listed in the nav pane by its request, like "GET httpbin.org/uuid",
+    # with its method in its style, like GET in :method_get.
+    Endpoint = Data.define(:project, :path, :line, :method, :url) do
+      def text = "#{method} #{address}"
+
+      # The URL without its scheme.
+      def address = url.sub(%r{\Ahttps?://}i, '')
+
+      def style = :"method_#{method.downcase}"
+    end
+  end
+end

data/lib/raindown/tui/endpoints.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'endpoint'
+require_relative 'views/endpoint_view'
+require_relative 'row'
+require_relative 'workers/worker'
+
+module Raindown
+  module TUI
+    # Every endpoint in the projects' files, found by each project's Worker, listed below the files.
+    # Like the dashboard, it can be narrowed to a project's own.
+    class Endpoints
+      # The project the endpoints are narrowed to, or nil for every project's.
+      attr_accessor :project
+
+      def initialize(workers:)
+        @workers = workers
+        load
+      end
+
+      # Finds the endpoints again, like after a file's changed.
+      def load
+        @endpoints = @workers.each.flat_map do |worker|
+          worker.call(:endpoints)
+        rescue Worker::Error
+          []
+        end
+      end
+
+      def all = project ? @endpoints.select { it.project == project } : @endpoints
+
+      def rows
+        all.map do
+          Row.new(text: it.address, tag: it, depth: 0, kind: :endpoint, target: it,
+                  open: OpenView.new(view: EndpointView.new(it, workers: @workers)))
+        end
+      end
+    end
+  end
+end

data/lib/raindown/tui/events.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A click on the screen: the cursor moves to the pane's row, or the dashboard's card or the menu's item,
+    # then the action's done there, like :enter, or a button's, like :toggle or :execute.
+    # Keys are their events' names, like :down or :enter.
+    Click = Data.define(:pane, :index, :action)
+
+    # What the Screen does after an event, other than drawing again, or stopping for :quit.
+    # Leaves the screen for a command, like the editor, then tells the Navigator it ran.
+    Run = Data.define(:command)
+
+    # Shows the message while the task runs, like an endpoint's request.
+    Wait = Data.define(:message, :task)
+
+    # Steps a row or a view asks of the Navigator, which each takes on it, returning what the Screen does next: to open
+    # a view right of the files, or a file in the outline at a directive, to edit a file at a line, or to run an endpoint.
+    OpenView = Data.define(:view) do
+      def take(navigator) = navigator.open_view(view)
+    end
+
+    Open = Data.define(:path, :line) do
+      def take(navigator) = navigator.open_at(path, line)
+    end
+
+    Edit = Data.define(:path, :line) do
+      def take(navigator) = navigator.edit_at(path, line)
+    end
+
+    Execute = Data.define(:path, :line, :name) do
+      def take(navigator) = navigator.run(path, line, name)
+    end
+  end
+end

data/lib/raindown/tui/file_tree.rb

@@ -1,52 +1,94 @@
 # frozen_string_literal: true
 
 require_relative '../projects'
+require_relative 'events'
+require_relative 'views/outline_view'
 require_relative 'row'
 
 module Raindown
   module TUI
-    # The files pane: a project's Markdown files as a tree, with folders before files, where folders fold.
+    # The nav pane's files: a project's Markdown files as a tree, with folders before files,
+    # including the files of the projects inside it, whose folders are marked with Raindown's cloud.
+    # Folders start folded, and open with Enter, or when a file in them opens.
+    # A scope narrows it to one project's own files, from the project's folder, like when it's chosen in the header.
     class FileTree
       attr_reader :root
+      # The project the files are narrowed to, or nil for all of them.
+      attr_accessor :scope
 
-      def initialize(root:)
+      def initialize(root:, workers:)
         @root = root
-        @folded = Set.new
+        @workers = workers
+        @expanded = Set.new
         load
       end
 
+      # The rain cloud without its emoji variation selector, which every terminal draws one column wide, so it lines up
+      # the files with the panes beside them. With the selector, as in the title, some terminals draw it two.
+      PROJECT = '🌧'
+
       def load
-        @files = Projects.files(root)
+        @files = Projects.files(root, nested: true)
+        @projects = Projects.roots(root).to_set
       end
 
+      # The folder the tree starts from: the scope's, or the root's.
+      def base = scope || root
+
       def rows
         tree = {}
-        @files.each { |path| relative(path).split('/').reduce(tree) { |node, part| node[part] ||= {} } }
+        files.each { |path| relative(path).split('/').reduce(tree) { |node, part| node[part] ||= {} } }
         tree_rows(tree, '', 0)
       end
 
       def toggle(folder)
-        @folded.delete?(folder) || @folded.add(folder)
+        @expanded.delete?(folder) || @expanded.add(folder)
+      end
+
+      # Opens the folders the file is in, so its row is shown.
+      def reveal(path)
+        folder = File.dirname(path)
+        while folder.start_with?(File.join(root, ''))
+          @expanded.add(folder)
+          folder = File.dirname(folder)
+        end
       end
 
       def relative(path)
-        path.delete_prefix(File.join(root, ''))
+        path.delete_prefix(File.join(base, ''))
       end
 
       private
 
+      # A scope's own files, without those of the projects inside it, which are projects of their own.
+      def files
+        return @files unless scope
+
+        @files.select { |path| owner(path) == scope }
+      end
+
+      def owner(path)
+        [root, *@projects].select { path.start_with?(File.join(it, '')) }.max_by(&:length)
+      end
+
       def tree_rows(tree, prefix, depth)
         folders, files = tree.partition { |_name, children| children.any? }
 
         folders.sort.flat_map { |name, children| folder_rows(name, children, prefix, depth) } +
-          files.sort.map { |name, _| Row.new(text: name, depth:, kind: :file, target: File.join(root, prefix, name)) }
+          files.sort.map { |name, _| file_row(name, File.join(base, prefix, name), depth) }
+      end
+
+      def file_row(name, path, depth)
+        Row.new(text: name, depth:, kind: :file, target: path, open: OpenView.new(view: OutlineView.new(path, workers: @workers)))
       end
 
       # A folder, and the tree inside it unless it's folded.
       def folder_rows(name, children, prefix, depth)
-        folder = File.join(root, prefix, name)
-        folded = @folded.include?(folder)
-        row = Row.new(text: "#{folded ? '▸' : '▾'} #{name}/", depth:, kind: :folder, target: folder)
+        folder = File.join(base, prefix, name)
+        folded = !@expanded.include?(folder)
+        project = @projects.include?(folder)
+        row = Row.new(text: "#{folded ? '▸' : '▾'} #{"#{PROJECT} " if project}#{name}/", depth:,
+                      kind: project ? :project : :folder, target: folder, fold: -> { toggle(folder) })
 
         [row, *(tree_rows(children, File.join(prefix, name), depth + 1) unless folded)]
       end

data/lib/raindown/tui/layout.rb

@@ -1,25 +1,35 @@
 # frozen_string_literal: true
 
-require 'unicode/display_width'
+require_relative 'events'
+require_relative 'text'
+require_relative 'title'
 
 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 +44,45 @@ module Raindown
       def lines
         return [status].first(height) if height < CHROME_HEIGHT + 1
 
-        [title, *panes, status, button_bar]
+        lines = [title, *panes, status, button_bar]
+        return lines unless navigator.menu
+
+        require_relative 'menu_overlay'
+        MenuOverlay.new(navigator, width:, column: display_width(name)).apply(lines)
       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)]
-      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 blank line above the panes, for spacing.
+      def spacer = [segment('', :blank, width: nav_width), divider([]), segment('', :blank, width: width - nav_width - 1)]
 
-        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 +90,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 +114,11 @@ 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'

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