canopus 0.3.0 → 0.4.0

data/lib/canopus/workspace/view.rb

@@ -27,6 +27,7 @@ module Canopus
     end
     def paint(bounds, _state, _prepaint, cx)
       @cx, @theme, @scene = cx, @workspace.theme, cx.scene
+      @children.clear
       @viewport_bounds = bounds
       @painted_palette = @workspace.palette
       @font_size = @workspace.settings["font_size"]
@@ -34,6 +35,7 @@ module Canopus
       @line_height = 20 if @cx.window.is_a?(Zaniah::Platform::TUI::Window)
       @regions.clear
       @row_layouts.clear
+      @overlay_rows = []
       @editor_bounds.clear
       @accessibility.clear
       @frame_diagnostics.clear
@@ -42,16 +44,21 @@ module Canopus
       @line_widths.delete_if { |editor, _| !visible_editors.include?(editor) }
       @code_caches.delete_if { |editor, _| !visible_editors.include?(editor) }
       fill(bounds, :background)
-      bottom_panel = @workspace.docks[:bottom][:visible] && @workspace.panels.values.any? { |side, _| side == :bottom }
-      bottom = @workspace.terminal_visible || bottom_panel ? [bounds.height * 0.7, @workspace.docks[:bottom][:size]].min : 0
-      sidebar = @workspace.show_project && @workspace.docks[:left][:visible] && bounds.width >= 620 ? [@workspace.docks[:left][:size], bounds.width * 0.4].min : 0
-      right = @workspace.docks[:right][:visible] && bounds.width >= 620 ? [@workspace.docks[:right][:size], bounds.width * 0.4].min : 0
+      left_panels = drawable_panels(:left)
+      bottom_panels = drawable_panels(:bottom)
+      bottom_visible = @workspace.docks[:bottom][:visible] && (@workspace.terminal_visible || !bottom_panels.empty?)
+      bottom = bottom_visible ? [bounds.height * 0.7, @workspace.docks[:bottom][:size]].min : 0
+      left_visible = @workspace.docks[:left][:visible] && (@workspace.show_project || !left_panels.empty?)
+      sidebar = left_visible && bounds.width >= 620 ? [@workspace.docks[:left][:size], bounds.width * 0.4].min : 0
+      right = @workspace.docks[:right][:visible] && !drawable_panels(:right).empty? && bounds.width >= 620 ? [@workspace.docks[:right][:size], bounds.width * 0.4].min : 0
       body = Zaniah::Bounds.new(sidebar, 0, bounds.width - sidebar - right, [bounds.height - 26 - bottom, 0].max)
       if sidebar.positive?
-        left_panels = @workspace.panels.values.any? { |side, _| side == :left }
-        project_height = left_panels ? (bounds.height - 26) * 0.6 : bounds.height - 26
-        paint_project(Zaniah::Bounds.new(0, 0, sidebar, project_height))
-        paint_panels(:left, Zaniah::Bounds.new(0, project_height, sidebar, bounds.height - 26 - project_height)) if left_panels
+        project_height = if @workspace.show_project
+          left_panels.empty? ? bounds.height - 26 : (bounds.height - 26) * 0.6
+        else 0
+        end
+        paint_project(Zaniah::Bounds.new(0, 0, sidebar, project_height)) if project_height.positive?
+        paint_panels(:left, Zaniah::Bounds.new(0, project_height, sidebar, bounds.height - 26 - project_height)) unless left_panels.empty?
       end
       paint_layout(@workspace.layout, body)
       if bottom.positive?
@@ -164,27 +171,34 @@ module Canopus
     end
     def paint_panels(side, bounds)
       fill(bounds, :panel)
-      panels = @workspace.panels.select { |_, (position, _)| position == side }.to_a
+      panels = drawable_panels(side)
       return if panels.empty?
-      panels.each_with_index do |(name, (_, render)), index|
+      panels.each_with_index do |definition, index|
         height = bounds.height / panels.length
         area = Zaniah::Bounds.new(bounds.x + 8, bounds.y + height * index, [bounds.width - 16, 0].max, height)
-        text(name, area.x + 4, area.y + 10, color: :muted, size: 12)
-        key = [name, @workspace.editor&.buffer&.object_id, @workspace.editor&.buffer&.version, @theme.object_id]
+        text(definition.title, area.x + 4, area.y + 10, color: :muted, size: 12)
+        if definition.badge
+          badge = Zaniah::Text.new(ui_text(definition.badge), size: 11, color: @theme[:accent])
+            .w(36).h(22).test_id("syrma:panel:#{instrumentation_component(definition.id)}:badge")
+          paint_element(badge, Zaniah::Bounds.new(area.right - 40, area.y + 5, 36, 22))
+        end
+        key = [definition.id, @workspace.editor&.buffer&.object_id, @workspace.editor&.buffer&.version, @theme.object_id]
         @panel_cache ||= {}
         @panel_cache.clear if @panel_cache.length > 50
-        element = @panel_cache[key] ||= render.call
-        element = Zaniah::Text.new(element.to_s, color: @theme[:foreground]) unless element.is_a?(Zaniah::Element)
-        root = element.request_layout(@cx)
-        Zaniah::Layout::Engine.new.compute(root, x: area.x, y: area.y + 34, width: area.width, height: [area.height - 34, 0].max)
+        element = @panel_cache[key] ||= definition.build.call
+        element = Zaniah::Text.new(ui_text(element), color: @theme[:foreground]) unless element.is_a?(Zaniah::Element)
+        panel = Zaniah::Div.new.w(area.width).h([area.height - 34, 0].max)
+          .test_id("syrma:panel:#{instrumentation_component(definition.id)}").child(element)
         @scene.clip(area) do
-          element.prepaint(root.bounds, nil, @cx)
-          element.paint(root.bounds, nil, nil, @cx)
+          paint_element(panel, Zaniah::Bounds.new(area.x, area.y + 34, area.width, [area.height - 34, 0].max))
         end
       rescue StandardError => error
         text(error.message, area.x, area.y + 34, color: :error, size: 12)
       end
     end
+    def drawable_panels(side)
+      @workspace.panels.active(side).reject { |definition| %w[terminal explorer search].include?(definition.id) }
+    end
     def paint_layout(node, bounds)
       return paint_pane(node[:pane], bounds) if node[:pane]
       horizontal = node[:direction] == :horizontal
@@ -244,7 +258,6 @@ module Canopus
       editor.viewport_rows = [(bounds.height / @line_height).floor, 1].max
       map, first = editor.display_map, editor.scroll_y.floor
       last = [first + editor.viewport_rows + 1, map.row_count].min
-      marks = @workspace.git_gutter_marks(editor.buffer)
       cursor_offset = @workspace.settings["vim_mode"] && active ? @workspace.vim.cursor_position : editor.primary.head
       cursor = map.to_display(cursor_offset)
       if map.wrap_map.width && !editor.buffer.read_only
@@ -262,6 +275,16 @@ module Canopus
         last = [first + editor.viewport_rows + 1, map.row_count].min
         cursor = map.to_display(cursor_offset)
       end
+      decorations = decorations_for_display_rows(editor, map, first, last)
+      if map.set_overlays(decorations.select { |item| %i[inline block].include?(item.kind) },
+        font: @cx.text_system&.font, font_size: @font_size, line_height: @line_height)
+        last = [first + editor.viewport_rows + 1, map.row_count].min
+        cursor = map.to_display(cursor_offset)
+        decorations = decorations_for_display_rows(editor, map, first, last)
+      end
+      gutter_items = decorations.select { |item| item.kind == :gutter }
+      highlight_items = decorations.select { |item| item.kind == :highlight }
+      line_items = decorations.select { |item| item.kind == :line }
       cursor_row = map.row(cursor.row)
       cursor_line = @cx.text_system&.layout_line(cursor_row.text, size: @font_size)
       brackets = []
@@ -286,35 +309,43 @@ module Canopus
         (first...last).each do |index|
           row = map.row(index)
           y = bounds.y + (index - editor.scroll_y) * @line_height + 4
-          fill(Zaniah::Bounds.new(bounds.x, y - 2, bounds.width, @line_height), :current_line) if cursor.row == index
           source_row = map.source_row(index)
-          change = marks.find do |mark|
-            first = [mark.new_line, 1].max
-            mark.kind == :removed ? source_row + 1 == first : (source_row + 1).between?(first, first + mark.count - 1)
-          end
-          if change
-            color = change.kind == :removed ? @theme[:error] : change.kind == :added ? "#80b987" : @theme[:accent]
-            fill(Zaniah::Bounds.new(bounds.x + 2, y - 1, 3, @line_height), color)
-            region(Zaniah::Bounds.new(bounds.x, y - 1, 10, @line_height), role: :button, label: "Toggle Git hunk", action: [:git_hunk, editor, source_row]) if row.kind == :text
+          fill(Zaniah::Bounds.new(bounds.x, y - 2, bounds.width, @line_height), :current_line) if cursor.row == index
+          paint_line_decorations(editor, source_row, y, bounds, line_items)
+          gutter_items.each do |item|
+            style = item.style.is_a?(Hash) ? item.style : {color: item.style, rows: 1}
+            next unless source_row.between?(item.row, item.row + style.fetch(:rows, 1) - 1)
+
+            marker = Zaniah::Bounds.new(bounds.x + 2, y - 1, 3, @line_height)
+            paint_instrumented_fill(marker, style.fetch(:color, :accent),
+              "syrma:decoration:gutter:#{source_row}:#{instrumentation_component(item.source)}")
+            if row.kind == :text && item.on_click
+              region(Zaniah::Bounds.new(bounds.x, y - 1, 10, @line_height), role: :button,
+                label: item.content.to_s, action: [:decoration, item.on_click, editor, source_row])
+            end
           end
           number = editor.relative_line_numbers ? (source_row - editor.buffer.rope.point_at(editor.primary.head).row).abs : source_row + 1
           number = source_row + 1 if number.zero?
           text(number, bounds.x + 12, y, color: cursor.row == index ? :foreground : :muted, size: @font_size - 1) if row.kind == :text
-          line = @cx.text_system&.layout_line(row.text, size: @font_size)
+          line, paint_overlays = prepare_inline_overlays(editor, row, left, y,
+            [bounds.width - gutter(editor), 1].max)
+          line ||= @cx.text_system&.layout_line(row.text, size: @font_size)
           measured_width = [measured_width, line&.width || row.text.length * @font_size * 0.6].max
           @row_layouts[[editor, index]] = line
-          paint_selections(editor, index, row, line, left, y)
+          paint_highlights(editor, index, row, line, left, y, highlight_items)
           brackets.each do |point|
             next unless point.row == index
             x = column_x(row.text, line, point.column)
             width = [column_x(row.text, line, point.column + 1) - x, 4].max
             fill(Zaniah::Bounds.new(left + x, y + @line_height - 2, width, 2), :accent)
           end
-          if row.kind == :text && line
+          if row.kind == :text && line && @cx.text_system
             spans = code_spans(editor, source_row, row)
             @cx.text_system.paint_line(@scene, line, x: left, y: y + line.ascent, color: @theme[:foreground], spans: spans)
             @cx.window.text_runs << [left, y, row.text, @theme[:foreground]]
-          else
+          elsif row.kind == :overlay_block
+            paint_block_overlay(editor, row.metadata, left, y, [bounds.width - gutter(editor), 1].max) if row.metadata
+          elsif row.kind != :overlay_block_continuation
             color = if row.kind == :git_diff
               row.text.start_with?("+") ? "#80b987" : row.text.start_with?("-") ? :error : :muted
             else
@@ -323,6 +354,7 @@ module Canopus
             text(row.text, left, y, color: color)
           end
           paint_diagnostics(editor, index, row, line, left, y) if row.kind == :text
+          paint_overlays&.call
           if cursor.row == index && active
             x = left + column_x(row.text, line, cursor.column)
             width = @workspace.settings["vim_mode"] && @workspace.vim.mode != :insert ? @font_size * 0.6 : 1.5
@@ -338,9 +370,10 @@ module Canopus
       previous_width = @line_widths[editor]
       measured_width = [measured_width, previous_width.last].max if previous_width && previous_width.first == editor.buffer.version
       @line_widths[editor] = [editor.buffer.version, measured_width]
-      paint_scrollbars(editor, bounds, measured_width, marks)
+      overview = @workspace.decorations.items_for(editor.buffer, 0...editor.buffer.line_count, context: editor)
+      paint_scrollbars(editor, bounds, measured_width, overview.select { |item| item.kind == :gutter })
     end
-    def paint_scrollbars(editor, bounds, content_width, marks)
+    def paint_scrollbars(editor, bounds, content_width, gutter_items)
       track = Zaniah::Bounds.new(bounds.right - 9, bounds.y, 9, [bounds.height - 9, 0].max)
       total = editor.display_map.row_count
       maximum = [total - editor.viewport_rows, 0].max
@@ -348,8 +381,8 @@ module Canopus
         height = [24, track.height * editor.viewport_rows / total].max.clamp(0, track.height)
         thumb = Zaniah::Bounds.new(track.x + 2, track.y + (track.height - height) * editor.scroll_y / maximum, 5, height)
         fill(thumb, :muted)
-        marks.first(500).each do |mark|
-          y = track.y + track.height * [mark.new_line - 1, 0].max / [editor.buffer.line_count, 1].max
+        gutter_items.first(500).each do |item|
+          y = track.y + track.height * item.row / [editor.buffer.line_count, 1].max
           fill(Zaniah::Bounds.new(track.x, y, 3, 2), :accent)
         end
         frame_diagnostics(editor.buffer).first(500).each do |diagnostic|
@@ -372,6 +405,97 @@ module Canopus
     def column_x(value, line, column)
       line ? line.x_for_index(value[0, column].to_s.bytesize) : column * @font_size * 0.6
     end
+    def decorations_for_display_rows(editor, map, first, last)
+      rows = (first...last).flat_map do |index|
+        row = map.row(index)
+        ending = map.to_buffer(DisplayPoint.new(index, row.text.length))
+        [map.source_row(index), editor.buffer.rope.point_at(ending).row]
+      end
+      rows.sort.uniq.slice_when { |left, right| right != left + 1 }.flat_map do |group|
+        @workspace.decorations.items_for(editor.buffer, group.first...(group.last + 1), context: editor)
+      end.uniq.sort_by(&:priority).freeze
+    end
+    def prepare_inline_overlays(editor, row, left, y, width)
+      return [nil, nil] unless row.kind == :text && row.metadata.is_a?(Array) && !row.metadata.empty?
+
+      overlay = Zaniah::Text.new(row.text, size: @font_size, color: "#0000", wrap: :none,
+        line_height: @line_height).w(width)
+      row.metadata.each do |placement|
+        overlay.inline_overlay(offset: placement.offset,
+          element: decoration_element(editor, placement.item, placement.width, placement.height)
+            .test_id("syrma:decoration:inline:#{editor.buffer.rope.point_at(placement.item.range.begin).row}"),
+          align: placement.align)
+      end
+      node = overlay.request_layout(@cx)
+      Zaniah::Layout::Engine.new.compute(node, x: left, y: y, width: width, height: @line_height)
+      overlay.prepaint(node.bounds, nil, @cx)
+      row.metadata.zip(overlay.children).each do |placement, element|
+        register_overlay_region(editor, placement.item, element.layout_node.bounds)
+      end
+      @overlay_rows << overlay
+      child(overlay)
+      paragraph = overlay.instance_variable_get(:@paragraph)
+      painter = -> { overlay.children.each { |child| child.paint(child.layout_node.bounds, nil, nil, @cx) } }
+      [paragraph.lines.first.layout, painter]
+    end
+    def paint_block_overlay(editor, block, left, y, width)
+      overlay = Zaniah::Text.new(" ", size: @font_size, color: "#0000", wrap: :none,
+        line_height: @line_height).w(width)
+      overlay.block_overlay(line: 0, position: :above, height: block.height,
+        element: decoration_element(editor, block.item, width, block.height))
+      node = overlay.request_layout(@cx)
+      Zaniah::Layout::Engine.new.compute(node, x: left, y: y, width: width, height: block.height + @line_height)
+      overlay.prepaint(node.bounds, nil, @cx)
+      register_overlay_region(editor, block.item, overlay.children.first.layout_node.bounds)
+      overlay.children.each { |child| child.paint(child.layout_node.bounds, nil, nil, @cx) }
+      @overlay_rows << overlay
+      child(overlay)
+    end
+    def paint_line_decorations(editor, source_row, y, bounds, items)
+      items.each do |item|
+        row = item.row || (item.range && editor.buffer.rope.point_at(item.range.begin).row)
+        next unless row == source_row
+
+        style = item.style.is_a?(Hash) ? item.style : {color: item.style}
+        area = Zaniah::Bounds.new(bounds.x + gutter(editor), y - 2,
+          [bounds.width - gutter(editor), 1].max, @line_height)
+        paint_instrumented_fill(area, style.fetch(:color, :current_line),
+          "syrma:decoration:line:#{source_row}:#{instrumentation_component(item.source)}")
+      end
+    end
+    def paint_instrumented_fill(bounds, color, test_id)
+      color = @theme[color] if color.is_a?(Symbol)
+      paint_element(Zaniah::Div.new.w(bounds.width).h(bounds.height).bg(color).test_id(test_id), bounds)
+    end
+    def paint_element(element, bounds)
+      child(element)
+      root = element.request_layout(@cx)
+      Zaniah::Layout::Engine.new.compute(root, x: bounds.x, y: bounds.y, width: bounds.width, height: bounds.height)
+      element.prepaint(root.bounds, nil, @cx)
+      element.paint(root.bounds, nil, nil, @cx)
+      element
+    end
+    def instrumentation_component(value) = value.to_s
+    def ui_text(value) = value.to_s.encode(Encoding::UTF_8)
+    def decoration_element(editor, item, width, height)
+      style = item.style.is_a?(Hash) ? item.style : {}
+      color = style.fetch(:color, item.style.is_a?(Symbol) ? item.style : :muted)
+      color = @theme[color] if color.is_a?(Symbol)
+      content = if item.content.respond_to?(:request_layout) && item.content.respond_to?(:paint)
+        item.content
+      else
+        Zaniah::Text.new(ui_text(item.content), size: [@font_size - 2, 1].max, color: color)
+      end
+      element = Zaniah::Div.new.w(width).h(height).items_center.child(content)
+      element.bg(style[:background]) if style[:background]
+      element
+    end
+    def register_overlay_region(editor, item, bounds)
+      return unless item.on_click
+      offset = item.range&.begin || editor.buffer.rope.line_start(item.row)
+      region(bounds, role: :button, label: item.content.to_s,
+        action: [:decoration, item.on_click, editor, offset])
+    end
     def code_spans(editor, source_row, row)
       return [] if editor.buffer.rope.respond_to?(:lazy?) && editor.buffer.rope.lazy?
       raw = editor.language_document.tokens_for(source_row)
@@ -425,24 +549,25 @@ module Canopus
     def frame_diagnostics(buffer)
       @frame_diagnostics[buffer] ||= @workspace.diagnostics_for(buffer)
     end
-    def paint_selections(editor, index, row, line, left, y)
-      editor.selections.each do |selection|
-        next if selection.empty?
+    def paint_highlights(editor, index, row, line, left, y, items)
+      items.each do |item|
+        range = item.range
+        next unless range
         if editor.buffer.rope.respond_to?(:lazy?)
           base = editor.buffer.rope.line_start(index)
-          first = selection.start - base
-          last = selection.end - base
+          first = range.begin - base
+          last = range.end - base
           next if last < row.offsets.first || first > row.offsets.last
           from = row.offsets.bsearch_index { |offset| offset >= first } || row.text.length
           to = row.offsets.bsearch_index { |offset| offset >= last } || row.text.length
           x = column_x(row.text, line, from)
-          fill(Zaniah::Bounds.new(left + x, y - 1, column_x(row.text, line, to) - x, @line_height), :selection)
+          fill(Zaniah::Bounds.new(left + x, y - 1, column_x(row.text, line, to) - x, @line_height), item.style)
           next
         end
-        span = selection_span(editor, selection, index)
+        span = highlight_span(editor, item, index)
         next unless span
-        before = selection_span(editor, selection, index - 1)
-        after = selection_span(editor, selection, index + 1)
+        before = highlight_span(editor, item, index - 1)
+        after = highlight_span(editor, item, index + 1)
         x, right = span
         # Only exposed convex corners are rounded; no alpha-overlapping bridge
         # and no convex hull that would highlight unselected source text.
@@ -450,11 +575,12 @@ module Canopus
           before && right > before[0] && right <= before[1] ? 0 : 3,
           after && right > after[0] && right <= after[1] ? 0 : 3,
           after && x >= after[0] && x < after[1] ? 0 : 3]
-        @scene.quad(left + x, y - 1, right - x, @line_height, color: @theme[:selection], radius: radii)
+        color = item.style.is_a?(Symbol) ? @theme[item.style] : item.style
+        @scene.quad(left + x, y - 1, right - x, @line_height, color: color, radius: radii)
       end
     end
-    def selection_span(editor, selection, index)
-      cache = @selection_spans[selection] ||= {first: editor.display_map.to_display(selection.start), last: editor.display_map.to_display(selection.end)}
+    def highlight_span(editor, item, index)
+      cache = @selection_spans[item] ||= {first: editor.display_map.to_display(item.range.begin), last: editor.display_map.to_display(item.range.end)}
       return cache[index] if cache.key?(index)
       first, last = cache.values_at(:first, :last)
       return unless index.between?(first.row, last.row)
@@ -587,8 +713,7 @@ module Canopus
     end
     def shortcut_labels
       return {} unless @keymap
-      context = {"Editor" => !!@workspace.editor,
-        "vim_mode" => @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false}
+      context = @workspace.palette&.dig(:command_context) || @workspace.command_context
       seen, labels = {}, {}
       @keymap.bindings.reverse_each do |binding|
         next unless binding.predicate.call(context)
@@ -627,7 +752,8 @@ module Canopus
           fill(row, :active_tab) if index == palette[:index]
           @scene.clip(row) { text(match, row.x + 10, row.y + 5, size: 13) }
           if palette[:kind] == :commands
-            shortcut = shortcuts[match]
+            command_index = palette[:indices] ? palette[:indices][index] : index
+            shortcut = shortcuts[palette[:command_definitions][command_index].id]
             if shortcut
               label = shortcut.tr("-", " ")
               x = row.right - label.length * 6.5 - 10

data/lib/canopus/workspace.rb

@@ -8,13 +8,16 @@ require_relative "vim"
 require_relative "lsp"
 require_relative "pane"
 require_relative "project/tree"
+require_relative "command"
+require_relative "panel"
+require_relative "decoration"
 
 module Canopus
   class Workspace
     ClosedTab = Data.define(:path, :selections, :scroll_x, :scroll_y, :pane_id, :index)
-    attr_reader :panes, :active_pane, :buffers, :actions, :settings, :theme, :project, :clients, :root, :docks, :panels
+    attr_reader :panes, :active_pane, :buffers, :actions, :commands, :settings, :theme, :project, :clients, :root, :docks, :panels, :decorations
     attr_reader :terminals, :active_terminal_index
-    attr_accessor :window, :show_project, :terminal_visible, :terminal_composition, :selected_project_path, :performance
+    attr_accessor :window, :terminal_composition, :selected_project_path, :performance
     attr_reader :message, :palette
 
     def initialize(root: Dir.pwd, settings: nil)
@@ -24,18 +27,47 @@ module Canopus
       @active_pane = @panes.first
       @layout = {pane: @active_pane}
       @theme = Theme.new(name: @settings["theme"])
-      @actions, @clients, @vim_states = Zaniah::Input::ActionRegistry.new, {}, {}
-      @show_project, @message = true, ""
+      @actions = @commands = Command::Registry.new
+      @clients, @vim_states = {}, {}
+      @message = ""
       @project = Project.new(@root) if defined?(Project)
-      bottom = @settings["dock"]["bottom"]
-      @docks = {left: {visible: true, size: 220}, right: {visible: false, size: 260},
-        bottom: {visible: bottom["visible"], size: bottom["size"]}}
-      @panels, @languages, @terminals = {}, {}, []
+      dock = @settings["dock"]
+      @docks = %i[left right bottom].to_h do |side|
+        value = dock.fetch(side.to_s)
+        [side, {visible: value["visible"], size: value["size"]}]
+      end
+      @panels = Panel::Registry.new(@docks)
+      @panels.restore(dock.fetch("panels"))
+      @panels.register(Panel::Definition.new("terminal", "Terminal", nil, :bottom, -> { terminal }, nil))
+      @panels.register(Panel::Definition.new("search", "Search", nil, :left, -> { palette_open(:project_search) }, nil))
+      @panels.register(Panel::Definition.new("explorer", "Explorer", nil, :left, -> { project_tree }, nil))
+      @decorations = Decoration::Registry.new
+      @decorations.register(:selection_match) do |buffer, rows, current|
+        selections = current.is_a?(Editor) && current.buffer.equal?(buffer) ? current.selections : buffer.selections
+        selections.filter_map do |selection|
+          next if selection.empty?
+          first = buffer.rope.point_at(selection.start).row
+          last = buffer.rope.point_at(selection.end).row
+          next if last < rows.begin || first >= rows.end
+
+          Decoration::Item.new(:highlight, selection.range, nil, nil, :selection, 100, :selection_match, nil)
+        end
+      end
+      @decorations.register(:git) { |buffer, rows| git_decorations(buffer, rows) }
+      @languages, @terminals = {}, []
       @active_terminal_index = 0
       @closed_tabs, @terminal_names = [], {}
       register_actions
     end
     def editor = @active_pane.active
+    def show_project = @panels.visible?("explorer")
+    def show_project=(visible)
+      visible ? @panels.show("explorer") : @panels.hide("explorer")
+    end
+    def terminal_visible = @panels.visible?("terminal") && @docks[:bottom][:visible]
+    def terminal_visible=(visible)
+      visible ? @panels.show("terminal") : @panels.hide("terminal")
+    end
     def terminal = @terminals[@active_terminal_index]
     def terminal=(value)
       @terminals.each { |item| item.close if !item.equal?(value) && item.respond_to?(:close) }
@@ -306,7 +338,7 @@ module Canopus
         queue_limit_bytes: options["queue_limit_bytes"])
       @terminals << created
       @active_terminal_index = @terminals.length - 1
-      @terminal_visible = true
+      self.terminal_visible = true
       resize_terminal(*@terminal_dimensions, final: true) if @terminal_dimensions
       @window&.request_frame
       created
@@ -352,7 +384,7 @@ module Canopus
       else
         @terminals.index(active) || 0
       end
-      @terminal_visible = false if @terminals.empty? && @settings["terminal"]["hide_when_empty"]
+      self.terminal_visible = false if @terminals.empty? && @settings["terminal"]["hide_when_empty"]
       @window&.request_frame
       current
     end
@@ -432,11 +464,13 @@ module Canopus
       dock[:visible] = !dock[:visible]
     end
     def register_panel(name, side: :left, &render)
-      raise ArgumentError, "invalid dock side" unless @docks.key?(side)
-      @panels[name] = [side, render]
-      register_action("panel.#{name}") { @docks[side][:visible] = true }
+      definition = @panels.register(Panel::Definition.new(name, name.to_s, nil, side, render, nil))
+      register_action("panel.#{name}") { @panels.show(definition.id) }
+      definition
+    end
+    def register_action(name, description: name, category: name.to_s.split(".", 2).first, condition: "", keybinding: Command::DEFAULT_KEYBINDINGS[name.to_s], &block)
+      @commands.register(Command::Definition.new(name.to_s, description, category, condition, block, keybinding))
     end
-    def register_action(name, description: name, &block) = @actions.register(name, description: description, &block)
     def definition_for(path)
       @languages.values.find { |definition| definition.extensions.include?(File.extname(path.to_s)) || definition.extensions.include?(File.basename(path.to_s)) } || Language.for_path(path)
     end
@@ -450,20 +484,32 @@ module Canopus
         end
       end
     end
-    def call(name, *args)
-      @actions.call(name, *args)
+    def command_context(terminal: false)
+      {"Terminal" => terminal, "Editor" => !!editor,
+       "vim_mode" => @settings["vim_mode"] && editor ? vim.mode.to_s : false}
+    end
+    def call(name, *args, context: nil)
+      context ||= @active_command_context || command_context
+      previous, @active_command_context = @active_command_context, context
+      @commands.call(name, *args, context: context)
       @window&.request_frame
     rescue StandardError => error
       @message = error.message
       @window&.request_frame
+    ensure
+      @active_command_context = previous
     end
 
     def theme=(theme)
       @theme = theme.is_a?(Theme) ? theme : Theme.new(name: theme)
       @window&.request_frame
     end
-    def palette_open(kind)
+    def palette_open(kind, command_ids: nil, context: nil)
       self.palette = {kind: kind, query: +"", index: 0, matches: []}
+      if kind == :commands
+        @palette[:command_context] = context || @active_command_context || command_context
+        @palette[:command_ids] = command_ids if command_ids
+      end
       if [:search, :replace_query, :project_search].include?(kind)
         @palette[:search_options] = {regexp: false, case_sensitive: true, whole_word: false, selection_only: false}
         @palette[:selection] = editor.primary.range unless editor.primary.empty?
@@ -478,6 +524,20 @@ module Canopus
     end
     def update_palette
       return unless @palette
+      if @palette[:kind] == :commands
+        context = @palette.fetch(:command_context)
+        definitions = @commands.each(context: context).to_a
+        ids = @palette[:command_ids]
+        definitions = definitions.select { |definition| ids.include?(definition.id) } if ids
+        @palette[:command_definitions] = definitions
+        session = @palette[:search] ||= Spica::Index.new(definitions.map(&:title)).session
+        session.query = @palette[:query]
+        matches = session.matches(12)
+        @palette[:indices] = matches.map(&:index)
+        @palette[:matches] = matches.map(&:candidate)
+        @palette[:index] = @palette[:index].clamp(0, [@palette[:matches].length - 1, 0].max)
+        return
+      end
       if [:completion, :locations, :symbols, :code_actions, :outline, :branches, :settings_keys, :snippet_choices].include?(@palette[:kind])
         labels = @palette[:all_matches] ||= @palette[:matches].dup
         session = @palette[:search] ||= Spica::Index.new(labels).session
@@ -489,7 +549,6 @@ module Canopus
         return
       end
       @palette[:search] ||= case @palette[:kind]
-      when :commands then Spica::Index.new(@actions.entries.keys).session
       when :files
         @finder_index ||= Spica::Index.new(((@recent_files || []).select { |path| File.file?(path) }.map { |path| path.delete_prefix(@root + File::SEPARATOR) } + files).uniq, tie_break: :index)
         @finder_index.session
@@ -525,12 +584,17 @@ module Canopus
         return
       end
       selected = @palette[:matches][@palette[:index]]
+      selected_command = if @palette[:kind] == :commands && selected
+        index = @palette[:indices] ? @palette[:indices][@palette[:index]] : @palette[:index]
+        @palette[:command_definitions][index]
+      end
+      command_context = @palette[:command_context]
       kind, query, pattern = @palette.values_at(:kind, :query, :pattern)
       self.palette = nil
       if kind == :files && selected
         open(selected)
-      elsif kind == :commands && selected
-        call(selected)
+      elsif kind == :commands && selected_command
+        call(selected_command.id, context: command_context)
       elsif kind == :search
         pattern, options = search_query(query, search_state)
         matches = editor.search(pattern, **options)
@@ -668,12 +732,15 @@ module Canopus
       register_action("edit.indent") { editor.indent }
       register_action("edit.outdent") { editor.indent(outdent: true) }
       register_action("search.buffer") { palette_open(:search) }
-      register_action("search.project") { palette_open(:project_search) }
+      register_action("search.project") { @panels.fetch("search").build.call }
       register_action("search.replace") { palette_open(:replace_query) }
       register_action("settings.open") { open_settings }
       register_action("settings.complete") { settings_completions }
       register_action("language.diagnostics") { show_diagnostics }
-      register_action("view.project") { @show_project = !@show_project }
+      register_action("view.project") { @panels.toggle("explorer") }
+      register_action("panel.explorer") { @panels.toggle("explorer") }
+      register_action("panel.search") { @panels.fetch("search").build.call }
+      register_action("panel.terminal") { @terminals.empty? ? new_terminal : @panels.toggle("terminal") }
       [:left, :right, :bottom].each { |side| register_action("view.dock_#{side}") { toggle_dock(side) } }
       register_action("view.wrap") { editor.display_map.wrap_width = editor.display_map.wrap_map.width ? nil : 100 }
       register_action("view.theme") { self.theme = @theme.name.include?("Dark") ? "Canopus Light" : "Canopus Dark" }
@@ -682,7 +749,7 @@ module Canopus
         clear_vim_states unless @settings["vim_mode"]
       end
       register_action("view.terminal") do
-        @terminals.empty? ? new_terminal : @terminal_visible = !@terminal_visible
+        @terminals.empty? ? new_terminal : @panels.toggle("terminal")
       end
       register_action("terminal.toggle") { call("view.terminal") }
       register_action("terminal.new") { new_terminal }

data/lib/canopus/wrap_map.rb

@@ -23,7 +23,9 @@ module Canopus
         end
       end
     end
-    def transform(text, offsets, checkpoint: nil)
+    def transform(text, offsets, checkpoint: nil, overlays: [], tab_map: nil)
+      text, offsets, overlays = tab_map.transform(text, offsets, checkpoint: checkpoint, overlays: overlays) if tab_map
+      return overlay_rows(text, offsets, overlays, checkpoint) unless overlays.empty?
       return pixel_rows(text, offsets, checkpoint) if @width && @font
       return [[text.freeze, offsets.freeze]] if !@width || (text.ascii_only? && text.length <= @width)
       rows, offset, chunk, positions, cells = [], 0, +"", [offsets.first], 0
@@ -53,6 +55,30 @@ module Canopus
     end
 
     private
+    def overlay_rows(text, offsets, overlays, checkpoint)
+      checkpoint&.call
+      typesetter = @font ? (@typesetters[Thread.current] ||= @layout_template.fork(capacity: 32)) : nil
+      scale = @font ? 1.0 : 0.6
+      width = @width ? @width * scale : Float::INFINITY
+      inline = overlays.map do |overlay|
+        Zaniah::TextSystem::Paragraph::InlineOverlay.new(overlay.object_id, overlay.offset,
+          (@font ? overlay.width : overlay.cell_width * scale), overlay.height, overlay.align)
+      end
+      paragraph = Zaniah::TextSystem::Paragraph.new(text, width: width,
+        size: @font ? @font_size : 1, line_height: @font ? nil : 1,
+        wrap: @width ? :anywhere : :none, typesetter: typesetter, inline_overlays: inline)
+      by_key = overlays.to_h { |overlay| [overlay.object_id, overlay] }
+      paragraph.lines.each_with_index.map do |line, index|
+        first = text.byteslice(0...line.start).to_s.length
+        last = first + line.layout.text.length
+        placements = paragraph.inline_placements.filter_map do |placement|
+          next unless placement.line == index
+          by_key.fetch(placement.key).with(offset: placement.offset - line.start)
+        end.freeze
+        [line.layout.text.freeze, offsets[first..last].freeze, placements]
+      end
+    end
+
     def pixel_rows(text, offsets, checkpoint)
       # The template is never used for shaping. Each owner copies its complete
       # typography without reading the rendering thread's mutable caches.

data/lib/canopus.rb

@@ -11,6 +11,9 @@ require "denebola"
 require "zaniah"
 require "porrima"
 require "thuban"
+require_relative "canopus/command"
+require_relative "canopus/panel"
+require_relative "canopus/decoration"
 require_relative "canopus/patch"
 require_relative "canopus/buffer"
 require_relative "canopus/multi_buffer"