raindown 0.5.1 → 0.7.0

data/lib/raindown/tui/commands.rb

@@ -1,70 +0,0 @@
-# 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.
-    # Each sets the status, so the Screen shows how it went, and returns what the Screen should do next, if anything.
-    module Commands
-      private
-
-      def execute
-        directive = selected(:outline)&.target if @focus == :outline
-        return error('Select an endpoint to run') unless directive.is_a?(Document::Directive) && directive.endpoint?
-
-        [:wait, "Running the endpoint on line #{directive.line}...", -> { run_endpoint(directive) }]
-      end
-
-      def run_endpoint(directive)
-        changed = Actions.execute(path, directive)
-        @outline.read
-        info(changed ? "Ran the endpoint on line #{directive.line}" : 'The response is the same')
-      rescue StandardError => e
-        error(e.message)
-      end
-
-      # In the files pane, the selected file opens at its top, and in the outline, the open file at the selected line.
-      def edit
-        row = selected
-        show(row.target) if @focus == :files && row&.kind == :file
-        return error('Open a file to edit') unless path
-
-        line = @focus == :outline && row ? row.line : 1
-        [:run, Actions.edit_command(path, line:)]
-      end
-
-      def write_back
-        return error('Open a file to write back') unless path
-
-        changed = Actions.write_back(path)
-        @outline.read
-        info(changed ? "Updated #{relative(path)}" : "#{relative(path)} is up to date")
-      rescue StandardError => e
-        error(e.message)
-      end
-
-      def reload
-        @files.load
-        @outline&.read if path && File.exist?(path)
-        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
-        @outline.read if @outline&.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/input.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'curses'
-require 'unicode/display_width'
-
-module Raindown
-  module TUI
-    # Turns curses' keys and clicks into a Navigator's events.
-    module Input
-      KEYS = {
-        Curses::KEY_UP => :up, 'k' => :up, Curses::KEY_DOWN => :down, 'j' => :down,
-        Curses::KEY_LEFT => :left, 'h' => :left, Curses::KEY_RIGHT => :right, 'l' => :right,
-        "\t" => :tab, Curses::KEY_BTAB => :tab, "\r" => :enter, "\n" => :enter, Curses::KEY_ENTER => :enter,
-        ' ' => :toggle, 'x' => :execute, 'e' => :edit, 'w' => :write_back, 'r' => :reload, 'q' => :quit
-      }.freeze
-
-      module_function
-
-      # A key from getch, which is a string for a printable character and otherwise a number.
-      def key_event(key)
-        key = key.chr if key.is_a?(Integer) && key < 256
-        KEYS[key]
-      end
-
-      # A scroll of the wheel moves the cursor, and a click sends the event of what's under it.
-      def mouse_event(event, zones)
-        wheel.find { |button, _| event.bstate.anybits?(button) }&.last || click(zones, column: event.x, row: event.y)
-      end
-
-      # Older ncurses has no fifth button, which is the wheel scrolling down.
-      def wheel
-        { Curses::BUTTON4_PRESSED => :up }.tap do |buttons|
-          buttons[Curses::BUTTON5_PRESSED] = :down if Curses.const_defined?(:BUTTON5_PRESSED)
-        end
-      end
-
-      # Where each of a Layout's segments with an event is on the screen, as [row, columns, event].
-      def zones(lines)
-        lines.each_with_index.flat_map do |segments, row|
-          column = 0
-          segments.filter_map do |segment|
-            width = Unicode::DisplayWidth.of(segment.text)
-            zone = [row, column...(column + width), segment.event] if segment.event
-            column += width
-            zone
-          end
-        end
-      end
-
-      def click(zones, column:, row:)
-        zones.find { |zone_row, columns, _event| zone_row == row && columns.cover?(column) }&.last
-      end
-    end
-  end
-end

data/lib/raindown/tui/navigator.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'file_tree'
-require_relative 'commands'
-require_relative 'outline'
-require_relative 'pane'
-
-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. The Screen draws it and sends it events, like :down or
-    # [:press, :outline, 3, :execute], and handle returns what the Screen should do next:
-    #   nil                     draw again
-    #   :quit                   stop
-    #   [:run, command]         leave the screen to run a command, like the editor, then call ran
-    #   [:wait, message, task]  show the message while the task runs, like an endpoint's request
-    class Navigator
-      include Commands
-
-      # 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: :files, right: :outline }.freeze
-      ACTIONS = { execute: :execute, edit: :edit, write_back: :write_back, reload: :reload, tick: :refresh }.freeze
-
-      attr_reader :focus, :status
-
-      def initialize(root:, path: nil)
-        @files = FileTree.new(root:)
-        @focus = :files
-        @panes = { files: Pane.new { @files.rows }, outline: Pane.new { @outline ? @outline.rows : [] } }
-        @status = [:info, 'Tab switches panes, Enter opens and folds, q quits']
-        first = @files.rows.find { it.kind == :file }&.target
-        show(path || first) if path || first
-      end
-
-      def handle(event)
-        name, *args = event
-        return :quit if name == :quit
-        return move(MOVES[name]) if MOVES.key?(name)
-        return switch(PANES[name] || other_pane) if PANES.key?(name)
-        return select(*args) if name == :select
-        return press(*args) if name == :press
-        return activate(name) if %i[enter toggle].include?(name)
-
-        send(ACTIONS[name]) if ACTIONS.key?(name)
-      end
-
-      # After the editor closes, the file is written back, like a save while it's watched, and read again.
-      def ran
-        write_back
-      end
-
-      def root = @files.root
-      def path = @outline&.path
-      def relative(path) = @files.relative(path)
-
-      def rows(pane) = @panes[pane].rows
-      def cursor(pane) = @panes[pane].cursor
-      def visible(pane, height) = @panes[pane].visible(height)
-
-      private
-
-      def show(path)
-        @outline = Outline.new(File.expand_path(path))
-        @panes[:outline].reset
-      end
-
-      def other_pane
-        @focus == :files ? :outline : :files
-      end
-
-      def move(by)
-        @panes[@focus].move(by)
-        nil
-      end
-
-      def switch(pane)
-        @focus = pane
-        nil
-      end
-
-      def select(pane, index)
-        @focus = pane
-        @panes[pane].cursor = index
-        nil
-      end
-
-      def press(pane, index, event)
-        select(pane, index)
-        handle(event)
-      end
-
-      def selected(pane = @focus)
-        @panes[pane].selected
-      end
-
-      # Enter opens what's selected, or folds it, and Space only folds.
-      # A line of output, or a directive without any, opens in the editor.
-      def activate(name)
-        row = selected
-        return edit if name == :enter && editable?(row)
-
-        case row&.kind
-        when :folder then @files.toggle(row.target)
-        when :file then open_file(row.target) if name == :enter
-        when :heading then @outline.fold(row.target)
-        when :directive then @outline.expand(row.target) if row.target.output
-        end
-        nil
-      end
-
-      def editable?(row)
-        row&.kind == :output || (row&.kind == :directive && !row.target.output)
-      end
-
-      def open_file(path)
-        show(path)
-        @focus = :outline
-        info("Opened #{relative(path)}")
-      end
-    end
-  end
-end

data/lib/raindown/tui/styles.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'curses'
-
-module Raindown
-  module TUI
-    # The curses attributes of a Layout's styles, in colour on the terminal's own background when it has colours.
-    module Styles
-      COLORS = { directive: Curses::COLOR_CYAN, button: Curses::COLOR_YELLOW, error: Curses::COLOR_RED,
-                 folder: Curses::COLOR_BLUE }.freeze
-
-      module_function
-
-      # Sets up the colours, once the screen has started, and returns the attribute of each style.
-      def start
-        colors = Curses.has_colors?
-        start_colors if colors
-        color = ->(name) { colors ? Curses.color_pair(COLORS.keys.index(name) + 1) : Curses::A_NORMAL }
-
-        {
-          title: Curses::A_REVERSE | Curses::A_BOLD, selected: Curses::A_REVERSE, cursor: Curses::A_UNDERLINE,
-          heading: Curses::A_BOLD, directive: color[:directive], output: Curses::A_DIM,
-          error: color[:error] | Curses::A_BOLD, button: color[:button] | Curses::A_BOLD,
-          selected_button: color[:button] | Curses::A_REVERSE, folder: color[:folder] | Curses::A_BOLD,
-          key: Curses::A_REVERSE, border: Curses::A_DIM
-        }
-      end
-
-      def start_colors
-        Curses.start_color
-        Curses.use_default_colors
-        COLORS.each_value.with_index(1) { |color, pair| Curses.init_pair(pair, color, -1) }
-      end
-    end
-  end
-end