raindown 0.5.0 → 0.6.0

data/lib/raindown/tui/text.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+module Raindown
+  module TUI
+    # Text measured in a terminal's columns, where a wide character like 界 takes two, cut to fit them in styled Segments.
+    module Text
+      Segment = Data.define(:text, :style, :event)
+      INDENT = '  '
+
+      private
+
+      # A path from the home folder when it's in it, like ~/dev/raindown.
+      def from_home(path)
+        home = Dir.home
+        path == home || path.start_with?(File.join(home, '')) ? path.sub(home, '~') : path
+      rescue ArgumentError
+        path
+      end
+
+      # The text fit to the width, as a Segment in the style.
+      def segment(text, style, width: self.width, event: nil)
+        Segment.new(text: fit(printable(text), width), style:, event:)
+      end
+
+      # Text cut or padded to the width, with a cut shown by an ellipsis.
+      def fit(text, width)
+        return '' if width <= 0
+        return text + (' ' * (width - display_width(text))) if display_width(text) <= width
+
+        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
+
+      # The widths of texts side by side in a width: each as wide as it is, and the last as wide as what's left,
+      # with none past the width.
+      def spread(texts, width)
+        texts.each_with_index.map do |text, index|
+          part = index == texts.length - 1 ? width : [display_width(text), width].min
+          width -= part
+          part
+        end
+      end
+
+      # The line's segments, with others drawn over its columns from the column on, like a box over the screen.
+      def overlay_segments(line, segments, column:)
+        width = segments.sum { display_width(it.text) }
+        [*segments_between(line, 0, column), *segments, *segments_between(line, column + width, Float::INFINITY)]
+      end
+
+      # The parts of the line's segments between two columns, where a wide character cut in two leaves spaces.
+      def segments_between(line, from, to)
+        column = 0
+        line.filter_map do |segment|
+          text = segment.text.each_char.map do |char|
+            start = column
+            column += display_width(char)
+            overlap = [column, to].min - [start, from].max
+            overlap == display_width(char) ? char : ' ' * [overlap, 0].max
+          end.join
+          segment.with(text:) unless text.empty?
+        end
+      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

data/lib/raindown/tui/title.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Raindown
+  module TUI
+    # A Layout's title line: Raindown's name, the folder the files are shown from, and the page.
+    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'
+
+      private
+
+      # The name, the folder, which opens the project menu when there's more than one project, and the page.
+      def title
+        parts = [[name, nil], ["#{location}#{' ▾' if navigator.projects?}", (:projects if navigator.projects?)],
+                 [" › #{view_renderer.page}", nil]]
+
+        parts.zip(spread(parts.map(&:first), width)).map do |(text, event), part_width|
+          segment(text, :title, width: part_width, event:)
+        end
+      end
+
+      def name = " #{NAME}  "
+
+      # The folder the files are shown from.
+      def location = from_home(navigator.base)
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+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.
+    # 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.
+      REDRAW = 2
+      MOVES = %i[up down left right].freeze
+      # Columns between the cards, and the narrowest a card is, with its border.
+      GAP = 2
+      MIN_CARD_WIDTH = 28
+
+      attr_reader :root, :errors, :cursor, :project
+
+      def initialize(root:, workers:)
+        @root = root
+        @workers = workers
+        @cursor = 0
+        @offset = 0
+        @rows = []
+      end
+
+      def renderer = DashboardRenderer
+      def target = self
+      def path = nil
+      def changed? = false
+
+      def status(_navigator)
+        found = "#{charts.length} #{charts.length == 1 ? 'chart' : 'charts'} in #{File.basename(project || root)}"
+        errors.empty? ? [:info, found] : [:error, "#{found}, but couldn't read #{errors.join(', ')}"]
+      end
+
+      # Finds the charts again, like when it's opened, or a file is saved or added.
+      def load
+        draw(find: true)
+        @cursor = @cursor.clamp(0, [charts.length - 1, 0].max)
+      end
+
+      # 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
+      end
+
+      # Narrows the charts to a project's, or with nil, shows every project's.
+      def project=(project)
+        @project = project
+        @cursor = 0
+        @offset = 0
+      end
+
+      def cards
+        draw if Process.clock_gettime(Process::CLOCK_MONOTONIC) - @drawn_at >= REDRAW
+        charts
+      end
+
+      # The charts' indexes in rows, as many of a project's as fit across the width after a column of margin, with each
+      # project's charts starting a row. They're kept, so up and down move a row.
+      def rows(width)
+        @rows = charts.each_index.chunk_while { |a, b| charts[a].project == charts[b].project }.flat_map { group_rows(it, width) }
+      end
+
+      # The widths a card can be: no narrower than MIN_CARD_WIDTH, when there's room, and no wider than the width.
+      def card_widths(width) = [MIN_CARD_WIDTH, width - 1].min..(width - 1)
+
+      def selected = charts[@cursor]
+
+      def first_in_row?
+        @rows.empty? || @rows.any? { it.first == @cursor }
+      end
+
+      # Every key but Tab to the files, or left from the first card in a row.
+      def next_step?(key) = !%i[tab tick].include?(key) && !(key == :left && first_in_row?)
+
+      def next_step(key)
+        chart = selected
+        case key
+        when *MOVES then move(key).then { nil }
+        when :enter then chart && Open.new(path: chart.path, line: chart.line)
+        when :edit then chart && Edit.new(path: chart.path, line: chart.line)
+        when :reload then load.then { nil }
+        end
+      end
+
+      def cursor=(index)
+        @cursor = index.clamp(0, [charts.length - 1, 0].max)
+      end
+
+      # The first row of cards to show, given each row's height, scrolled so the cursor's row is shown.
+      def scroll(row_heights, height)
+        row = row_of(@cursor)
+        @offset = row if row < @offset
+        @offset += 1 while @offset < row && row_heights[@offset..row].sum > height
+        @offset = @offset.clamp(0, [row_heights.length - 1, 0].max)
+      end
+
+      private
+
+      def draw(find: false)
+        @cards = []
+        @errors = []
+        @workers.each do |worker|
+          answer = worker.call(:charts, find:)
+          @cards.concat(answer[:cards])
+          @errors.concat(answer[:errors])
+        rescue Worker::Error => e
+          @errors << "#{File.basename(worker.root)}: #{e.message}"
+        end
+        @cards.sort_by! { [it.project, it.path, it.line] }
+        @drawn_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def group_rows(indexes, width)
+        indexes.each_with_object([[]]) do |index, rows|
+          rows << [] if rows.last.any? && row_width(rows.last + [index], width) > width
+          rows.last << index
+        end
+      end
+
+      # A row of cards' width, after a column of margin, with a gap between each.
+      def row_width(row, width)
+        1 + row.sum { charts[it].box_width(within: card_widths(width)) } + (GAP * (row.length - 1))
+      end
+
+      # Left and right move along the cards, and up and down to the card in the same place in the row above or below.
+      def move(name)
+        return self.cursor = @cursor + (name == :left ? -1 : 1) if %i[left right].include?(name)
+
+        row = row_of(@cursor)
+        target = @rows[(row + (name == :up ? -1 : 1)).clamp(0, [@rows.length - 1, 0].max)]
+        self.cursor = target ? target[[@rows[row].index(@cursor), target.length - 1].min] : @cursor
+      end
+
+      def row_of(index)
+        @rows.index { it.include?(index) } || 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative '../events'
+require_relative '../workers/worker'
+
+module Raindown
+  module TUI
+    # An endpoint opened from the files, beside them: its request, and the response its file has, read by its project's
+    # Worker when it's opened, which scrolls.
+    # A key's next step, for the Navigator, is nil, an Open or Edit of its directive, or an Execute of it.
+    class EndpointView
+      # The date a response was fetched, on the line after it.
+      FETCHED = /raindown:fetched (\S+)/
+      FENCE = /\A\s*`{3,}(\S*)/
+
+      attr_reader :endpoint, :response, :language, :fetched, :error
+
+      def initialize(endpoint, workers:)
+        @endpoint = endpoint
+        @workers = workers
+        @offset = 0
+      end
+
+      def renderer = EndpointRenderer
+      def target = endpoint
+      def path = endpoint.path
+      def status(_navigator) = [:info, endpoint.text]
+      def changed? = false
+      def next_step?(key) = %i[up down enter edit execute].include?(key)
+
+      # Clicks on the response only move the focus to it.
+      def cursor=(_index); end
+
+      # Reads the response again, like after the request's run.
+      def load
+        lines = output_lines
+        @fetched = lines.pop[FETCHED, 1] if lines.last&.match?(FETCHED)
+        @language = lines.first.to_s[FENCE, 1]
+        @response = @language ? lines[1...-1] : lines
+        @error = nil
+      rescue Worker::Error => e
+        @response = []
+        @error = e.message
+      end
+
+      def next_step(key)
+        case key
+        when :up, :down then scroll(key == :up ? -1 : 1)
+        when :enter then Open.new(path: endpoint.path, line: endpoint.line)
+        when :edit then Edit.new(path: endpoint.path, line: endpoint.line)
+        when :execute then Execute.new(path: endpoint.path, line: endpoint.line, name: endpoint.text)
+        end
+      end
+
+      # The response's lines that fit in the height, from where it's scrolled to.
+      def visible(height)
+        @offset = @offset.clamp(0, [response.length - height, 0].max)
+        response[@offset, height] || []
+      end
+
+      private
+
+      def output_lines
+        outline = @workers.for(path).call(:outline, path)
+        directive = outline.directives.find { it.endpoint? && it.line == endpoint.line }
+        directive&.output ? outline.lines[(directive.output.begin - 1)...directive.output.end] : []
+      end
+
+      def scroll(by)
+        @offset += by
+        nil
+      end
+    end
+  end
+end

data/lib/raindown/tui/{pane.rb → views/list_view.rb}

@@ -2,8 +2,8 @@
 
 module Raindown
   module TUI
-    # A pane's cursor and how far it's scrolled, over rows that can change between draws, like when a folder folds.
-    class Pane
+    # Rows with a cursor, and how far they're scrolled, which can change between draws, like when a folder folds.
+    class ListView
       attr_writer :cursor
 
       def initialize(&rows)
@@ -12,6 +12,8 @@ module Raindown
         @offset = 0
       end
 
+      def renderer = ListRenderer
+
       def rows = @rows.call
       def selected = rows[cursor]
 
@@ -20,13 +22,12 @@ module Raindown
         @cursor.clamp(0, [rows.length - 1, 0].max)
       end
 
+      # Moves past rows that can't be selected, like separators, and stays at the first or last row rather than moving off them.
       def move(by)
-        @cursor = (cursor + by).clamp(0, [rows.length - 1, 0].max)
-      end
-
-      def reset
-        @cursor = 0
-        @offset = 0
+        rows = self.rows
+        index = cursor + by
+        index += by while index.between?(0, rows.length - 1) && !rows[index].selectable?
+        @cursor = index if index.between?(0, rows.length - 1)
       end
 
       # The rows that fit in the height, scrolled so the cursor's row is one of them, and the first one's index.

data/lib/raindown/tui/{outline.rb → views/outline_view.rb}

@@ -1,30 +1,41 @@
 # frozen_string_literal: true
 
-require_relative '../document'
-require_relative 'row'
+require_relative '../../document'
+require_relative '../events'
+require_relative 'list_view'
+require_relative '../row'
+require_relative '../workers/worker'
 
 module Raindown
   module TUI
-    # The outline pane: a file's headings and directives, read from its Document. Headings fold the section below them,
-    # and a directive's output, the lines Raindown wrote back, expands below it. Both start folded away.
-    class Outline
+    # The outline: a file's headings and directives, read by its project's Worker. Headings fold the section below them,
+    # and a directive's body expands below it, like the lines a node wrote back or an endpoint's request and response.
+    # Both start folded away. It's read when it's opened, and it's a ListView, with its own cursor.
+    class OutlineView < ListView
       attr_reader :path, :error
 
-      def initialize(path)
+      def initialize(path, workers:)
+        super()
         @path = path
+        @workers = workers
         @folded = Set.new
         @expanded = Set.new
-        read
       end
 
+      def renderer = OutlineRenderer
+      def target = path
+      def next_step?(_key) = false
+      def status(navigator) = [:info, "Opened #{navigator.relative(path)}"]
+
       # Reads the file again, keeping what's folded.
-      def read
+      def load
         @mtime = File.mtime(path)
-        @document = Document.read(path)
-        @lines = File.readlines(path, chomp: true)
-        @document.directives # Finds an error in the file, like a missing end tag, now rather than while drawing.
+        outline = @workers.for(path).call(:outline, path)
+        @lines = outline.lines
+        @headings = outline.headings
+        @directives = outline.directives
         @error = nil
-      rescue StandardError => e
+      rescue Worker::Error, SystemCallError => e
         @error = e.message
       end
 
@@ -72,34 +83,42 @@ module Raindown
 
       # Headings a directive wrote are part of its output, so they show when it's expanded rather than on their own.
       def items
-        outputs = @document.directives.filter_map(&:output)
-        @document.outline.reject { |item| item.is_a?(Document::Heading) && outputs.any? { it.cover?(item.line) } }
+        outputs = @directives.filter_map(&:output)
+        (@headings + @directives).sort_by(&:line)
+                                 .reject { |item| item.is_a?(Document::Heading) && outputs.any? { it.cover?(item.line) } }
       end
 
       def min_level
-        @document.headings.map(&:level).min || 1
+        @headings.map(&:level).min || 1
       end
 
       def heading_row(heading)
         folded = @folded.include?(heading.line) ? ' …' : ''
         Row.new(text: "#{'#' * heading.level} #{heading.text}#{folded}", depth: heading.level - min_level, kind: :heading,
-                target: heading)
+                target: heading, fold: -> { fold(heading) })
       end
 
       def directive_rows(directive, depth:)
         expanded = @expanded.include?(directive.line)
         row = Row.new(text: directive_text(directive), depth:, kind: :directive, target: directive,
-                      buttons: buttons(directive, expanded:))
+                      buttons: buttons(directive, expanded:), **directive_action(directive))
         return [row] unless expanded
 
-        [row, *directive.output.map do |number|
-          Row.new(text: @lines[number - 1].to_s, depth: depth + 1, kind: :output, target: number)
+        [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))
         end]
       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) } }
+        else { open: Edit.new(path:, line: directive.line) }
+        end
+      end
+
       def buttons(directive, expanded:)
         buttons = []
-        buttons << [expanded ? '[-]' : "[+#{directive.output.size}]", :toggle] if directive.output
+        buttons << [expanded ? '[-]' : "[+#{directive.body.size}]", :toggle] if directive.body
         buttons << ['[Run]', :execute] if directive.endpoint?
         buttons
       end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../../actions'
+require_relative '../../bare_directives'
+require_relative '../../chart/chart'
+require_relative '../../document'
+require_relative '../../front_matter'
+require_relative '../../node_blocks'
+require_relative '../../nodes'
+require_relative '../../pages'
+require_relative '../../projects'
+require_relative '../card'
+require_relative '../endpoint'
+require_relative '../../code_blocks'
+require_relative '../../endpoint/curl'
+
+module Raindown
+  module TUI
+    # What the terminal UI asks of a project, answered in the project's Worker with its own nodes loaded,
+    # so two projects' nodes of the same name stay apart. Answers are plain data, which a Worker sends back through a pipe.
+    class Project
+      Outline = Data.define(:lines, :headings, :directives)
+
+      attr_reader :root
+
+      # The projects inside this one have workers of their own, so their files are left out.
+      def initialize(root:)
+        @root = root
+        @load_errors = []
+        @file_errors = []
+        Nodes.load(File.join(root, Nodes::FOLDER))
+      rescue StandardError, ScriptError => e
+        @load_errors << "#{File.basename(root)}/#{Nodes::FOLDER}: #{e.message}"
+      end
+
+      # A file's lines, headings and directives.
+      def outline(path)
+        document = Document.read(path)
+        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.
+      # 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?
+          @file_errors = []
+          @charts = Projects.files(root).flat_map { |path| charts_in(path) }
+        end
+
+        { cards: drawn, errors: @load_errors + @file_errors }
+      end
+
+      # Every endpoint in the project's files, by its request, leaving out 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)
+          Document.read(path).directives.select(&:endpoint?).filter_map { |directive| endpoint(path, lines, directive) }
+        rescue StandardError
+          []
+        end
+      end
+
+      def write_back(path)
+        Actions.write_back(path)
+      end
+
+      # Runs the endpoint on the line, replacing its response.
+      def execute(path, line)
+        directive = Document.read(path).directives.find { it.line == line && it.endpoint? }
+        raise Actions::NotAnEndpoint, "There's no endpoint on line #{line}" unless directive
+
+        Actions.execute(path, directive)
+      end
+
+      private
+
+      def endpoint(path, lines, directive)
+        snippet = CodeBlocks.endpoint(lines, directive.line).first&.dig(:body)
+        request = Curl.request(snippet.to_s)
+        Endpoint.new(project: root, path:, line: directive.line, **request.to_h) if request
+      end
+
+      def charts_in(path)
+        content = File.read(path, encoding: Encoding::UTF_8)
+        bare = BareDirectives.enabled?(path:, content:)
+        lines = content.lines
+        headings = Document.parse(content, bare:).headings
+
+        NodeBlocks.find(lines, front_matter: FrontMatter.parse(content).first, bare:)
+                  .select { |block| block[:node].is_a?(Raindown::Chart) }
+                  .map { |block| chart(block, path:, lines:, headings:) }
+      rescue StandardError => e
+        @file_errors << "#{path.delete_prefix(File.join(root, ''))}: #{e.message}"
+        []
+      end
+
+      def drawn
+        pages = {}
+        @charts.map do |chart|
+          lines = lines(chart, pages[File.dirname(chart[:path])] ||= Pages.for(chart[:path]))
+          Card.new(project: root, chart: lines, **chart.except(:node))
+        end
+      end
+
+      def chart(block, path:, lines:, headings:)
+        line = block[:open] + 1
+        directive = lines[block[:open]].strip.delete_prefix('<{').delete_suffix('}>').strip
+
+        { 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.
+      def lines(chart, metadata)
+        node = chart[:node]
+        points = node.points(metadata:)
+        points.empty? ? ['No data'] : node.draw(points).map(&:rstrip)
+      rescue StandardError => e
+        ["Can't chart: #{e.message}"]
+      end
+    end
+  end
+end