raindown 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae1eb87d8271ddcfcc3fb956311e11229421188a33f5bd7e0af70cffd2f49719
-  data.tar.gz: 380a98d835cfa9de899c5870828ba157e89aa0d3a4b8621a495f1a0ecd1e9bf6
+  metadata.gz: c9a61e7a842dcd5dc4cc5f6d004db388173ef2d5c48af1a50e32fea6c317b678
+  data.tar.gz: 7bbae724e020d48a3f095ba1cc8e1c45b9ee5dd483daf0af5f8edd4333d83205
 SHA512:
-  metadata.gz: b3e74f64840850c572446865664e5368915df5065f09e9483d530d58392acb13f0e20ce872b9f8ee1930154af82d4c3baf8bf6fbd7c370399315e3b7a3a3b480
-  data.tar.gz: '09a95ee90ef2568aff8c783ecee3b2ac06590f0a71f1bde6e14e99e7e8f5c6e05776ca6ff3c7dcce22fd55a56e456273ecb0de2475fceb0785a312a022cd48fa'
+  metadata.gz: b8f312582ede3900be43490c52c54ce3df6292764c04c177f54510e397a4814c9a9184cbb0710113055bb0dd140f00ced0bcf309f59583d34485a900579ac64b
+  data.tar.gz: 932d51981cd38660a402a40bbf9b0015da35baf62bad04152cdfdc262287f9593643daf66d2b60b6282e4df8a3de553a9ebba1793b37bec0972c145ea275c5a0

data/lib/raindown/actions.rb

@@ -30,7 +30,7 @@ module Raindown
       raise NotAnEndpoint, "#{directive.name} on line #{directive.line} isn't an endpoint" unless directive.endpoint?
 
       content = File.read(path, encoding: Encoding::UTF_8)
-      rewritten = EndpointRunner.new(content:, bare: BareDirectives.file?(path), only: directive.line - 1).rewrite
+      rewritten = EndpointRunner.new(content:, bare: BareDirectives.enabled?(path:, content:), only: directive.line - 1).rewrite
       return false if rewritten == content
 
       File.write(path, rewritten)

data/lib/raindown/bare_directives.rb

@@ -5,7 +5,8 @@ require_relative 'front_matter'
 
 module Raindown
   # Raindown files (.rd/.raindown) can write a directive like <{ if: draft }> as a bare if: draft on its own line.
-  # Markdown files opt in with the --bare flag. Nodes like toc: and files: are handled by NodeBlocks, before the rest.
+  # Markdown files opt in with "raindown: true" in their front matter, or with the --bare flag.
+  # Nodes like toc: and files: are handled by NodeBlocks, before the rest.
   #
   # Bare directives have no end tag. A bare block directive closes itself after the content it applies to,
   # so where a block needs to wrap more than that, write it with delimiters and an end tag instead:
@@ -24,8 +25,8 @@ module Raindown
 
     module_function
 
-    def enabled?(path: nil, bare: false)
-      bare || file?(path)
+    def enabled?(path: nil, content: nil, bare: false)
+      bare || file?(path) || front_matter?(content)
     end
 
     def file?(path)
@@ -34,6 +35,16 @@ module Raindown
       EXTENSIONS.include?(File.extname(path).downcase)
     end
 
+    # Whether the front matter has "raindown: true". Front matter that isn't valid YAML fails when the file renders,
+    # so here it only means no.
+    def front_matter?(content)
+      return false unless content&.start_with?('---')
+
+      FrontMatter.parse(content).first[:raindown] == true
+    rescue Psych::Exception
+      false
+    end
+
     # Wrap each bare directive in Antlers delimiters and close its block, leaving code and front matter as-is.
     def expand(content)
       lines = content.lines

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,13 +29,14 @@ 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:)
     end
 
-    # Raindown files read bare directives. A project's own nodes are only directives once they're loaded,
-    # like with Nodes.load(path), the same as when the file renders.
+    # Raindown files read bare directives, as do Markdown files with "raindown: true" front matter.
+    # A project's own nodes are only directives once they're loaded, like with Nodes.load(path), the same as when the file renders.
     def self.read(path)
       new(markdown: File.read(path, encoding: Encoding::UTF_8), bare: BareDirectives.file?(path))
     end
@@ -41,7 +44,7 @@ module Raindown
     def initialize(markdown:, bare: false)
       @markdown = markdown
       @lines = markdown.lines
-      @bare = bare
+      @bare = bare || BareDirectives.front_matter?(markdown)
     end
 
     # The headings in the order they appear, with their source text, like "Notes for {name}" before it's rendered.
@@ -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/endpoint/endpoint_runner.rb

@@ -26,7 +26,7 @@ module Raindown
     FETCHED = /\A {0,3}<!-- raindown:fetched [^\n]*? -->[ \t]*$/
 
     def self.rewrite(content:, path: nil, bare: false, execute: false, **)
-      new(content:, bare: BareDirectives.enabled?(path:, bare:), execute:).rewrite
+      new(content:, bare: BareDirectives.enabled?(path:, content:, bare:), execute:).rewrite
     end
 
     def initialize(content:, bare: false, execute: false, only: nil)

data/lib/raindown/node_injector.rb

@@ -18,7 +18,7 @@ module Raindown
 
     def initialize(content:, path: nil, bare: false, metadata: NoMetadata)
       @content = content
-      @bare = BareDirectives.enabled?(path:, bare:)
+      @bare = BareDirectives.enabled?(path:, content:, bare:)
       @metadata = metadata
     end
 

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