canopus 0.4.0 → 0.5.0

data/lib/canopus/controller.rb

@@ -8,10 +8,19 @@ module Canopus
     def initialize(workspace, window)
       @workspace, @window, @view = workspace, window, Workspace::View.new(workspace)
       workspace.window = window
-      workspace.register_action("terminal.copy", condition: "Terminal") { terminal_copy }
-      workspace.register_action("terminal.paste", condition: "Terminal") do
+      workspace.register_action("terminal.copy", condition: "Terminal || TaskOutput") { terminal_copy }
+      workspace.register_action("terminal.paste", condition: "Terminal || TaskOutput") do
         terminal_paste(@window.respond_to?(:clipboard) ? @window.clipboard.to_s : @clipboard)
       end
+      workspace.register_action("terminal.command.previous", description: "Go to Previous Terminal Command", condition: "Terminal") do
+        @view.terminal_command(:previous)
+      end
+      workspace.register_action("terminal.command.next", description: "Go to Next Terminal Command", condition: "Terminal") do
+        @view.terminal_command(:next)
+      end
+      workspace.register_action("terminal.command.toggle_fold", description: "Toggle Terminal Command Output", condition: "Terminal") do
+        @view.terminal_toggle_command
+      end
       reload_keymap
       window.draw { workspace.drain; @view }
       window.on_input { |event| input(event) }
@@ -19,20 +28,30 @@ module Canopus
       window.on_appearance { |_| workspace.apply_settings if workspace.settings["theme"] == "auto" } if window.respond_to?(:on_appearance)
       window.on_tick do
         workspace.drain_terminals
+        workspace.drain_task_outputs
         workspace.drain
         workspace.poll_changes
         workspace.poll_settings
+        workspace.poll_auto_save
+        workspace.poll_recovery
         reload_keymap
         workspace.poll_git_changes
         poll_display_maps
         poll_language_documents
         poll_scroll
         window.request_frame if @view.tick
+        window.close if wait_complete?
       end
-      @clipboard, @terminal_focus = "", false
+      @clipboard, @terminal_focus = "", nil
       workspace.new_buffer unless workspace.editor
     end
+    def wait_for(paths)
+      @wait_paths = paths.map { |path| @workspace.canonical_path(path) }.uniq
+    end
     def input(event)
+      return if focused_ui_widget? &&
+        [Zaniah::Input::KeyDown, Zaniah::Input::TextInput, Zaniah::Input::Composition].any? { |type| event.is_a?(type) }
+
       case event
       when Zaniah::Input::KeyUp, Zaniah::Input::MouseDown, Zaniah::Input::FileDrop
         @suppress_key_text = false
@@ -55,7 +74,7 @@ module Canopus
       when Zaniah::Input::TextInput
         input_text(event.text)
       when Zaniah::Input::Composition
-        if @terminal_focus && @workspace.terminal_visible
+        if focused_terminal
           @workspace.terminal_composition = event
         else
           @workspace.new_buffer unless @workspace.editor
@@ -67,18 +86,41 @@ module Canopus
         mouse_down(event)
       when Zaniah::Input::MouseMove
         mouse_move(event) if @drag
+        if @minimap_drag
+          pane, editor = @minimap_drag
+          @view.minimap_scroll(editor, event.position) if @workspace.panes.include?(pane) && pane.editors.include?(editor)
+        end
         resize_drag(event.position) if @resize_drag
         scroll_drag(event.position) if @scroll_drag
         if @terminal_drag
           @terminal_drag == :selection ? @view.terminal_select(event.position, extend: true) : terminal_mouse(event, :move)
-        elsif !(@drag || @resize_drag || @scroll_drag || @drag_file || @drag_tab) &&
-            @workspace.terminal_visible && @workspace.terminal&.vt&.modes&.[](1003) && @view.hit(event.position)&.first == :terminal
-          terminal_mouse(event, :move)
+        elsif !(@drag || @resize_drag || @scroll_drag || @drag_file || @drag_tab)
+          hit = @view.hit(event.position)
+          target = hit&.first
+          terminal = if target == :terminal
+            hit[1] if @workspace.terminal_visible
+          elsif target == :terminal_command
+            hit[2] if @workspace.terminal_visible
+          elsif target == :task_output
+            @workspace.task_terminal if @workspace.task_output_visible
+          end
+          @view.focus_terminal(terminal) if terminal
+          terminal_mouse(event, :move, terminal: terminal) if terminal&.vt&.modes&.[](1003)
+        end
+        unless @drag || @resize_drag || @scroll_drag || @minimap_drag || @drag_file || @drag_tab || @terminal_drag
+          target = @view.hit(event.position)
+          if target&.first == :editor
+            current = target.last
+            @workspace.debug_hover(current, @view.offset_at(current, event.position))
+          else
+            @workspace.debug_hover(nil, nil)
+          end
         end
       when Zaniah::Input::MouseUp
-        @workspace.flush_terminal_resize if @resize_drag&.first == :dock_resize
+        @workspace.flush_terminal_resize if @resize_drag
         @resize_drag = nil
         @scroll_drag = nil
+        @minimap_drag = nil
         if @drag_file
           path, origin = @drag_file
           target = @view.hit(event.position)
@@ -122,12 +164,13 @@ module Canopus
     end
     def input_text(text)
       if @workspace.palette
-        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file].include?(@workspace.palette[:kind])
+        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file, :recovery,
+          :breakpoint_actions].include?(@workspace.palette[:kind])
         @workspace.palette[:query] << text
         @workspace.update_palette
-      elsif @terminal_focus && @workspace.terminal_visible
+      elsif (terminal = focused_terminal)
         @workspace.terminal_composition = nil
-        @workspace.terminal.write(text)
+        terminal.write(text)
       else
         @workspace.new_buffer unless @workspace.editor
         if @workspace.settings["vim_mode"]
@@ -144,15 +187,16 @@ module Canopus
       stroke = Zaniah::Input::Keystroke.normalize(stroke)
       return palette_key(stroke) if @workspace.palette
       return if @composing && (stroke.split("-") & %w[ctrl cmd]).empty?
-      if stroke == "cmd-q" || stroke == "ctrl-q" && !(@terminal_focus && @workspace.terminal_visible)
+      if stroke == "cmd-q" || stroke == "ctrl-q" && !focused_terminal
         return @window.close
       end
-      if @terminal_focus && @workspace.terminal_visible && @workspace.terminal
-        if stroke == "enter" && @workspace.terminal.respond_to?(:alive?) && !@workspace.terminal.alive?
+      if (terminal = focused_terminal)
+        if terminal_focused? && stroke == "enter" && terminal.respond_to?(:alive?) && !terminal.alive?
           return @workspace.restart_terminal
         end
         mode = @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false
-        context = @workspace.command_context(terminal: true).merge("Editor" => false, "vim_mode" => mode)
+        context = @workspace.command_context(terminal: terminal_focused?,
+          task_output: @terminal_focus == :task_output).merge("Editor" => false, "vim_mode" => mode)
         action = @keymap.dispatch(stroke, context: context)
         if action && action != :pending
           @drag_terminal_tab = nil if action == "terminal.close"
@@ -166,7 +210,7 @@ module Canopus
         name = parts.pop
         return if (name.length == 1 || name == "space") && (parts & %w[ctrl alt cmd]).empty?
         name = {"esc" => "escape", "pageup" => "page_up", "pagedown" => "page_down", "space" => " "}.fetch(name, name)
-        return @workspace.terminal.key(name, control: parts.include?("ctrl"), alt: parts.include?("alt"), shift: parts.include?("shift"))
+        return terminal.key(name, control: parts.include?("ctrl"), alt: parts.include?("alt"), shift: parts.include?("shift"))
       end
       return @workspace.settings_completions if stroke == "ctrl-space" && @workspace.editor && @workspace.settings_document?(@workspace.editor.buffer)
       mode = @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false
@@ -225,20 +269,37 @@ module Canopus
       candidates = visible + (inactive.empty? ? [] : [inactive[@language_poll_index % inactive.length]])
       candidates.each do |editor|
         document = editor.language_document
+        sticky = false
         if visible.include?(editor)
+          @workspace.request_document_highlights(editor)
+          @workspace.request_document_links(editor)
           map = editor.display_map
           first = editor.scroll_y.floor.clamp(0, map.row_count - 1)
           last = [first + editor.viewport_rows, first + 255, map.row_count - 1].min
+          sticky = @workspace.sticky_scroll_enabled?(editor)
+          symbols = sticky || @workspace.breadcrumbs_enabled?(editor)
           cached = @language_viewports[editor]
           # The persistent display tree changes on edits, folds, blocks and
           # completed wrap batches. Idle polls need not walk every visible row.
           unless cached && cached[0].equal?(document) && cached[1].equal?(map.tree) &&
-              cached[2] == editor.buffer.version && cached[3] == first && cached[4] == last
-            document.request(rows: (first..last).map { |row| map.source_row(row) }.uniq)
-            @language_viewports[editor] = [document, map.tree, editor.buffer.version, first, last]
+              cached[2] == editor.buffer.version && cached[3] == first && cached[4] == last && cached[7] == symbols
+            rows = (first..last).map { |row| map.source_row(row) }.uniq.sort
+            document.request(rows: rows, syntax: symbols)
+            inlay_ranges = @workspace.visible_inlay_hint_ranges(editor, first...(last + 1))
+            lens_ranges = @workspace.visible_code_lens_ranges(editor, first...(last + 1))
+            cached = @language_viewports[editor] = [document, map.tree, editor.buffer.version, first, last, inlay_ranges, lens_ranges, symbols]
+          end
+          cached[5].each do |rows|
+            @workspace.request_inlay_hints(editor, rows, start: true)
           end
+          cached[6].each do |rows|
+            @workspace.request_code_lenses(editor, rows, start: true)
+          end
+          @workspace.request_sticky_symbols(editor) if symbols
         end
         changed = document.poll
+        @workspace.refresh_sticky_fallback(editor, document) if visible.include?(editor) && symbols && document.syntax_ready?
+        @workspace.invalidate_brackets(editor.buffer) if changed
         @workspace.language_ready(editor, document)
         @window.request_frame if changed
       rescue StandardError => error
@@ -300,6 +361,17 @@ module Canopus
     end
 
     private
+    def wait_complete?
+      return false unless @wait_paths
+      return false if @wait_paths.any? do |path|
+        @workspace.panes.any? { |pane| pane.editors.any? { |editor| editor.buffer.path == path } }
+      end
+      @wait_paths = nil
+      true
+    end
+
+    def focused_ui_widget? = !@window.dispatcher.focused.nil?
+
     def reload_keymap
       language = @workspace.editor&.language_document&.definition&.name
       groups = @workspace.settings["languages"].dig(language, "keymap") || @workspace.settings["keymap"]
@@ -324,7 +396,7 @@ module Canopus
     end
     def palette_input(event)
       return false unless @workspace.palette
-      @drag = @resize_drag = @scroll_drag = @terminal_drag = @drag_file = @drag_tab = @drag_terminal_tab = nil
+      @drag = @resize_drag = @scroll_drag = @minimap_drag = @terminal_drag = @drag_file = @drag_tab = @drag_terminal_tab = nil
       case event
       when Zaniah::Input::KeyDown then key(event.keystroke)
       when Zaniah::Input::TextInput then input_text(event.text)
@@ -337,7 +409,7 @@ module Canopus
       editor = @workspace.editor
       if operation == "v"
         value = @window.respond_to?(:clipboard) ? @window.clipboard : @clipboard
-        editor.insert_text(value.to_s, auto_indent: false)
+        editor.insert_text(value.to_s, auto_indent: false, pair: false)
       else
         value = editor.selections.map { |selection| editor.buffer.rope.byteslice(selection.range).to_s }.join("\n")
         @clipboard = value
@@ -370,7 +442,8 @@ module Canopus
           palette[:details_scroll] = (palette.fetch(:details_scroll, 0) + (stroke == "pageup" ? -step : step)).clamp(0, maximum)
         end
       when "backspace"
-        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file].include?(palette[:kind])
+        return if [:workspace_edit, :confirm_close, :confirm_tab_close, :confirm_terminal_close, :confirm_terminal_paste, :trash_file, :recovery,
+          :breakpoint_actions].include?(palette[:kind])
         palette[:query] = palette[:query].grapheme_clusters[0...-1].join
         @workspace.update_palette
       when "enter"
@@ -391,6 +464,8 @@ module Canopus
           elsif result["failureReason"] != "User cancelled"
             @workspace.message = result["failureReason"].to_s
           end
+        elsif palette[:kind] == :recovery
+          @workspace.resolve_recovery(palette[:index].zero? ? :restore : :discard)
         elsif palette[:kind] == :confirm_close
           case palette[:index]
           when 0
@@ -410,11 +485,15 @@ module Canopus
           @workspace.close_terminal(index) if palette[:index].zero? && index
         elsif palette[:kind] == :confirm_terminal_paste
           value = palette[:text]
+          terminal = palette[:terminal]
           @workspace.palette = nil
-          @workspace.terminal&.paste(value) if palette[:index].zero?
+          terminal&.paste(value) if palette[:index].zero?
         elsif palette[:kind] == :terminal_rename
           @workspace.rename_terminal(palette[:query])
           @workspace.palette = nil
+        elsif palette[:kind] == :terminal_commands
+          command = @workspace.palette_accept
+          @workspace.message = "Command output is no longer in scrollback" if command && !@view.terminal_command_jump(command)
         else
           @workspace.palette_accept
         end
@@ -423,6 +502,7 @@ module Canopus
     def mouse_down(event)
       action = @view.hit(event.position)
       return unless action
+      @window.dispatcher.focus(nil)
       kind, *args = action
       return if @workspace.palette && (kind != :palette || event.button != :left)
       if [:file, :directory].include?(kind)
@@ -434,16 +514,34 @@ module Canopus
           return
         end
       end
-      @terminal_focus = [:terminal, :terminal_tab, :terminal_close].include?(kind)
+      @terminal_focus = if [:terminal, :terminal_command, :terminal_tab, :terminal_close].include?(kind)
+        :terminal
+      elsif [:task_output, :task_output_tab, :task_output_close].include?(kind)
+        :task_output
+      end
+      if kind == :terminal || kind == :terminal_command
+        current = kind == :terminal ? args.first : args[1]
+        if current && (index = @workspace.terminals.index(current))
+          @workspace.activate_terminal(index)
+          @view.focus_terminal(current)
+        end
+      elsif kind == :task_output && args.first
+        @view.focus_terminal(args.first)
+      end
       case kind
-      when :decoration
-        args[0].call(args[1], args[2]) if event.button == :left
+      when :decoration, :context_decoration
+        if event.button == :left
+          args[0].call(args[1], args[2])
+        elsif event.button == :right && args[0].respond_to?(:right_click)
+          args[0].right_click(args[1], args[2])
+        end
       when :git_hunk then @workspace.toggle_git_hunk(args[0], row: args[1]) if event.button == :left
       when :hover_link
         return unless event.button == :left
         uri = URI.parse(args.first)
         @window.open_url(uri.to_s) if %w[http https].include?(uri.scheme) && uri.host && @window.respond_to?(:open_url)
       when :dismiss_notification then @workspace.dismiss_notification(args.first)
+      when :buffer_format then @workspace.show_encoding_actions(args.first) if event.button == :left
       when :pane then @workspace.focus(args.first)
       when :split_resize, :dock_resize then @resize_drag = action
       when :scrollbar
@@ -454,9 +552,15 @@ module Canopus
         grab = coordinate.between?(start, start + length) ? coordinate - start : length / 2.0
         @scroll_drag = [editor, direction, track, thumb, maximum, grab]
         scroll_drag(event.position)
-      when :terminal
+      when :minimap
+        pane, editor = args
+        if event.button == :left && pane.active.equal?(editor) && @view.minimap_scroll(editor, event.position)
+          @workspace.focus(pane)
+          @minimap_drag = [pane, editor]
+        end
+      when :terminal, :task_output
         return if event.button == :left && @view.terminal_open_link(event.position, modifiers: event.modifiers)
-        tracking = [1000, 1002, 1003].any? { |mode| @workspace.terminal.vt.modes[mode] }
+        tracking = [1000, 1002, 1003].any? { |mode| focused_terminal.vt.modes[mode] }
         if tracking && !event.modifiers.map(&:to_s).include?("shift")
           @terminal_drag = event.button
           terminal_mouse(event, :press)
@@ -464,11 +568,20 @@ module Canopus
           @terminal_drag = :selection
           @view.terminal_select(event.position)
         end
+      when :terminal_command
+        @view.terminal_toggle_command(args.first) if event.button == :left
       when :terminal_tab
         @workspace.activate_terminal(args.first)
         @drag_terminal_tab = [args.first, event.position] if event.button == :left
       when :terminal_close
         @workspace.request_terminal_close(args.first) if event.button == :left
+      when :task_output_tab
+        @workspace.activate_task_output(args.first)
+      when :task_output_close
+        output = @workspace.task_outputs[args.first]
+        if event.button == :left && output
+          @workspace.task_runner.running?(output) ? @workspace.stop_task(output) : @workspace.close_task_output(args.first)
+        end
       when :file then @workspace.open(args.first)
       when :directory then @workspace.project_tree.toggle(args.first)
       when :tab
@@ -495,7 +608,19 @@ module Canopus
           editor.move(:line_start)
           editor.move(:down, extend: true)
         end
-        @drag = [editor, editor.primary.anchor, event.position, modifiers.include?("alt") && modifiers.include?("shift")]
+        rectangle = modifiers.include?("alt") && event.click_count == 1
+        @drag = [editor, rectangle ? anchor : editor.primary.anchor, event.position, rectangle]
+      when :sticky
+        pane, editor, offset, version, generation = args
+        if event.button == :left && editor.buffer.version == version &&
+            @workspace.document_symbol_generation(editor) == generation && pane.editors.include?(editor)
+          @workspace.activate_tab(pane, editor)
+          editor.select(offset)
+          editor.reveal_cursor
+        end
+      when :breadcrumb
+        pane, editor, item, context = args
+        @workspace.show_breadcrumb_menu(pane, editor, item, context) if event.button == :left
       when :palette
         @workspace.palette[:index] = args.first
         palette_key("enter")
@@ -510,8 +635,13 @@ module Canopus
       cancel_scroll
       raise ArgumentError, "scroll deltas must be finite" unless [event.delta.x, event.delta.y].all? { |value| value.is_a?(Numeric) && value.finite? }
       action = @view.hit(event.position)
-      if [:editor, :scrollbar].include?(action&.first)
-        editor = action.first == :editor ? action.last : action[1]
+      if [:editor, :scrollbar, :sticky, :breadcrumb, :minimap].include?(action&.first)
+        editor = case action.first
+        when :editor then action.last
+        when :sticky, :breadcrumb then action[2]
+        when :minimap then action[2]
+        else action[1]
+        end
         editor.scroll(dx: event.delta.x, dy: event.delta.y / 20.0)
         # Cocoa already supplies native momentum deltas (numeric NSEvent phase).
         # Other backends get a bounded decaying tail; zero friction disables it.
@@ -520,10 +650,14 @@ module Canopus
         end
       elsif [:file, :directory].include?(action&.first)
         @view.project_scroll(event.delta.y / 24.0)
-      elsif action&.first == :terminal
-        if [1000, 1002, 1003].any? { |mode| @workspace.terminal.vt.modes[mode] }
-          column, row = @view.terminal_point(event.position)
-          @workspace.terminal.mouse(button: event.delta.y.positive? ? :wheel_down : :wheel_up, column: column, row: row)
+      elsif [:terminal, :terminal_command, :task_output].include?(action&.first)
+        terminal = action.first == :terminal_command ? action[2] : action[1]
+        terminal ||= action.first == :task_output ? @workspace.task_terminal : @workspace.terminal
+        @view.focus_terminal(terminal)
+        if [1000, 1002, 1003].any? { |mode| terminal.vt.modes[mode] }
+          if (position = @view.terminal_point(event.position))
+            terminal.mouse(button: event.delta.y.positive? ? :wheel_down : :wheel_up, column: position[0], row: position[1])
+          end
         else
           @view.terminal_scroll(event.delta.y / 20.0)
         end
@@ -539,25 +673,34 @@ module Canopus
         editor.scroll(dx: fraction.clamp(0, 1) * maximum - editor.scroll_x)
       end
     end
-    def terminal_mouse(event, action)
-      column, row = @view.terminal_point(event.position)
+    def terminal_mouse(event, action, terminal: focused_terminal)
+      return unless terminal
+      position = @view.terminal_point(event.position)
+      return unless position
+      column, row = position
       modifiers = event.modifiers.map(&:to_s)
-      @workspace.terminal.mouse(button: @terminal_drag, column: column, row: row, action: action,
+      terminal.mouse(button: @terminal_drag, column: column, row: row, action: action,
         shift: modifiers.include?("shift"), alt: modifiers.include?("alt"), control: modifiers.include?("ctrl"))
     end
 
     def terminal_paste(text)
       if @workspace.settings["terminal"]["confirm_multiline_paste"] && text.match?(/[\r\n].*[\r\n]?/m)
         @workspace.palette = {kind: :confirm_terminal_paste, query: "Paste multiple lines into the terminal?", index: 1,
-          matches: ["Paste", "Cancel"], text: text}
+          matches: ["Paste", "Cancel"], text: text, terminal: focused_terminal}
       else
-        @workspace.terminal.paste(text)
+        focused_terminal&.paste(text)
       end
     end
     def terminal_copy
       @clipboard = @view.terminal_selected_text
       @window.clipboard = @clipboard if @window.respond_to?(:clipboard=)
     end
+    def focused_terminal
+      return @workspace.terminal if terminal_focused? && @workspace.terminal_visible
+      return @workspace.task_terminal if @terminal_focus == :task_output && @workspace.task_output_visible
+      nil
+    end
+    def terminal_focused? = @terminal_focus == :terminal || @terminal_focus == true
     def resize_drag(point)
       kind, target, bounds = @resize_drag
       if kind == :split_resize