canopus 0.1.0 → 0.2.0

data/lib/canopus/workspace/git_aware.rb

@@ -4,7 +4,7 @@ module Canopus
   module Workspace::GitAware
     def git
       return @git if defined?(@git)
-      @git = Git::Repository.new(@root)
+      @git = Thuban::Repository.new(@root)
       @git = nil unless @git.root
     rescue ArgumentError
       @git = nil
@@ -29,7 +29,7 @@ module Canopus
     end
     def invalidate_git
       @git_generation = (@git_generation || 0) + 1
-      @git_status = @git_hunk_cache = nil
+      @git_status = @git_diff_cache = nil
       @panes.each do |pane|
         pane.editors.each do |current|
           current.display_map.block_map.blocks.values.each { |block| current.display_map.remove_block(block.id) if block.kind == :git_diff }
@@ -57,43 +57,48 @@ module Canopus
       raise Error, "Current document is not in a Git repository" unless git && buffer.path && buffer.path.start_with?(git.root + File::SEPARATOR)
       buffer.path.delete_prefix(git.root + File::SEPARATOR)
     end
-    def git_hunks(buffer = editor.buffer, async: true)
-      return [] unless git && buffer.path && buffer.path.start_with?(git.root + File::SEPARATOR) && buffer.rope.bytesize < 10 << 20
+    def git_diff(buffer = editor.buffer, async: true)
+      return unless git && buffer.path && buffer.path.start_with?(git.root + File::SEPARATOR) && buffer.rope.bytesize < 10 << 20
       path = git_relative_path(buffer)
-      @git_hunk_cache ||= {}
+      @git_diff_cache ||= {}
       key = [buffer.object_id, path, buffer.version, git.head]
-      @git_hunk_cache.clear if @git_hunk_cache.length > 20
-      return @git_hunk_cache[key] if @git_hunk_cache.key?(key)
+      @git_diff_cache.clear if @git_diff_cache.length > 20
+      return @git_diff_cache[key] if @git_diff_cache.key?(key)
       if @window && async
-        @git_hunk_jobs ||= {}
-        unless @git_hunk_jobs[buffer]&.alive?
+        @git_diff_jobs ||= {}
+        unless @git_diff_jobs[buffer]&.alive?
           snapshot = buffer.rope
-          @git_hunk_jobs[buffer] = Thread.new do
+          @git_diff_jobs[buffer] = Thread.new do
             before = Buffer.decode_bytes(git.blob(path, reference: key.last || "HEAD").to_s).first
-            hunks = Git::Diff.hunks(before, snapshot.to_s, context: 0)
-            post { (@git_hunk_cache ||= {})[key] = hunks } unless @closed
+            diff = Porrima.diff(before, snapshot.to_s, context: 0)
+            diff.hunks
+            diff.marks
+            post { (@git_diff_cache ||= {})[key] = diff } unless @closed
           rescue StandardError => error
             post { @message = "Git diff: #{error.message}" } unless @closed
           end
         end
-        []
+        nil
       else
         before = Buffer.decode_bytes(git.blob(path).to_s).first
-        @git_hunk_cache[key] = Git::Diff.hunks(before, buffer.text, context: 0)
+        diff = Porrima.diff(before, buffer.text, context: 0)
+        diff.hunks
+        diff.marks
+        @git_diff_cache[key] = diff
       end
     end
+    def git_hunks(buffer = editor.buffer, async: true) = git_diff(buffer, async: async)&.hunks || []
+    def git_gutter_marks(buffer = editor.buffer) = git_diff(buffer)&.marks || []
     def show_git_diff
       path = git_relative_path
       before = Buffer.decode_bytes(git.blob(path).to_s).first
-      buffer = Buffer.new(Git::Diff.unified(before, editor.buffer.text, old_name: "a/#{path}", new_name: "b/#{path}"), read_only: true)
+      buffer = Buffer.new(Porrima.unified(before, editor.buffer.text, old_name: "a/#{path}", new_name: "b/#{path}"), read_only: true)
       @buffers[buffer.object_id] = buffer
       @active_pane.open(buffer).language = Language::Definition.new("diff", "diff", [], "", /\A\z/, /\A\z/, [])
     end
     def toggle_git_hunk(current = editor, row: nil)
       row ||= current.buffer.rope.point_at(current.primary.head).row
-      hunk = git_hunks(current.buffer, async: false).find do |item|
-        (row + 1).between?([item.new_start, 1].max, [item.new_start + item.new_count - 1, item.new_start].max)
-      end
+      hunk = git_diff(current.buffer, async: false)&.hunk_at(new_line: row + 1)
       raise Error, "No change at the cursor" unless hunk
       id = [:git_hunk, current.buffer.path, current.buffer.version, git.head, hunk.old_start, hunk.new_start]
       map = current.display_map
@@ -122,9 +127,9 @@ module Canopus
     end
     def revert_current_hunk
       row = editor.buffer.rope.point_at(editor.primary.head).row + 1
-      hunk = git_hunks(async: false).find { |item| row.between?([item.new_start, 1].max, [item.new_start + item.new_count - 1, item.new_start].max) }
+      hunk = git_diff(async: false)&.hunk_at(new_line: row)
       raise Error, "No change at the cursor" unless hunk
-      replacement = Git::Diff.revert(editor.buffer.text, hunk)
+      replacement = Porrima.revert(editor.buffer.text, hunk)
       editor.buffer.edit([[0...editor.buffer.rope.bytesize, replacement]], kind: :revert_hunk)
     end
     def checkout_branch(name)

data/lib/canopus/workspace/session_persistable.rb

@@ -20,6 +20,8 @@ module Canopus
       end
       state = {version: 2, root: @root, layout: encode_layout(@layout), recent_files: @recent_files || [],
         active_pane: @panes.index(@active_pane), docks: @docks,
+        terminals: @terminals.map { |current| {cwd: current.vt.cwd || (current.respond_to?(:initial_cwd) ? current.initial_cwd : @root), title: @terminal_names[current]} },
+        active_terminal: @active_terminal_index, terminal_visible: !!@terminal_visible,
         panes: @panes.map do |pane|
           {active: pane.active_index, tabs: pane.editors.map do |current|
             {buffer_id: record.call(current.buffer), cursor: current.primary.head, pinned: pane.pinned.include?(current),
@@ -133,6 +135,7 @@ module Canopus
       end
       active = data.fetch("active_pane", 0)
       raise Error, "invalid active pane" unless active.is_a?(Integer) && active.between?(0, restored_panes.length - 1)
+      terminal_records = validate_session_terminals(data) if @settings["terminal"]["restore_on_startup"]
       clear_vim_states
       close_language_documents
       @panes.each { |pane| pane.editors.each(&:dispose) }
@@ -140,7 +143,7 @@ module Canopus
       @panes, @buffers, @layout, @docks = restored_panes, restored_buffers, restored_layout, restored_docks
       @active_pane = @panes[active]
       @recent_files = Array(data["recent_files"]).select { |item| item.is_a?(String) && File.file?(item) }.first(100)
-      new_buffer unless editor
+      restore_terminals(data, terminal_records) if terminal_records
       self
     rescue StandardError
       unless @panes.equal?(restored_panes)
@@ -149,5 +152,33 @@ module Canopus
       end
       raise
     end
+
+    private
+
+    def validate_session_terminals(data)
+      records = data.fetch("terminals", [])
+      raise Error, "invalid session terminals" unless records.is_a?(Array) && records.length <= 100 && records.all? { |item| item.is_a?(Hash) && item["cwd"].is_a?(String) }
+      active = data.fetch("active_terminal", 0)
+      raise Error, "invalid active terminal" unless records.empty? || active.is_a?(Integer) && active.between?(0, records.length - 1)
+      records
+    end
+
+    def restore_terminals(data, records)
+      old, old_index, old_visible = @terminals, @active_terminal_index, @terminal_visible
+      @terminals = []
+      records.each do |record|
+        cwd = File.directory?(record["cwd"]) ? record["cwd"] : @root
+        created = new_terminal(cwd: cwd)
+        rename_terminal(record["title"], created) if record["title"].is_a?(String)
+      end
+      @active_terminal_index = @terminals.empty? ? 0 : data.fetch("active_terminal", 0)
+      @terminal_visible = !!data["terminal_visible"] && !@terminals.empty?
+      old.each { |current| current.close if current.respond_to?(:close) }
+    rescue StandardError
+      @terminals.each { |current| current.close if current.respond_to?(:close) }
+      @terminals = old
+      @active_terminal_index, @terminal_visible = old_index, old_visible
+      @message = "Session restored; terminals could not start"
+    end
   end
 end

data/lib/canopus/workspace/view/terminal_presentable.rb

@@ -65,7 +65,7 @@ module Canopus
     def terminal_point(point)
       grid = @workspace.terminal.grid
       column = ((point.x - @terminal_bounds.x) / @terminal_cell_width).floor.clamp(0, grid.columns - 1)
-      row = ((point.y - @terminal_bounds.y) / @line_height).floor.clamp(0, grid.rows - 1)
+      row = ((point.y - @terminal_bounds.y) / (@terminal_line_height || @line_height)).floor.clamp(0, grid.rows - 1)
       [column, row]
     end
     def terminal_scroll(delta)
@@ -136,15 +136,36 @@ module Canopus
     end
     def render_terminal(bounds)
       fill(bounds, :panel)
+      @terminal_bounds = nil
       terminal = @workspace.terminal
-      return unless terminal
-      text(terminal.vt.title.to_s.empty? ? "Terminal" : terminal.vt.title, bounds.x + 12, bounds.y + 5, color: :muted, size: 12)
-      @terminal_cell_width = @cx.text_system&.layout_line("M", size: @font_size)&.width || @font_size * 0.6
-      columns = [(bounds.width - 24) / @terminal_cell_width, 1].max.floor
-      rows = [(bounds.height - 28) / @line_height, 1].max.floor
-      terminal.resize(columns: columns, rows: rows) if terminal.grid.columns != columns || terminal.grid.rows != rows
+      unless terminal
+        text("No terminals — Ctrl+Shift+` to create one", bounds.x + 12, bounds.y + 8, color: :muted, size: 12)
+        return
+      end
+      if @terminal_owner != terminal
+        @terminal_owner, @terminal_scroll, @terminal_selection = terminal, 0, nil
+      end
+      x = bounds.x
+      @workspace.terminals.each_with_index do |current, index|
+        label = @workspace.terminal_title(current)
+        width = [[label.length * 7.5 + 42, 100].max, 220].min
+        tab = Zaniah::Bounds.new(x, bounds.y, width, 28)
+        fill(tab, :active_tab) if current.equal?(terminal)
+        text(label, tab.x + 10, tab.y + 6, color: current.equal?(terminal) ? :foreground : :muted, size: 12)
+        region(tab, role: :tab, label: label, action: [:terminal_tab, index])
+        close = Zaniah::Bounds.new(tab.right - 25, tab.y, 25, tab.height)
+        text("×", close.x + 6, close.y + 5, color: :muted, size: 12)
+        region(close, role: :button, label: "Close #{label}", action: [:terminal_close, index])
+        x += width
+      end
+      @terminal_font_size = @workspace.settings["terminal"]["font_size"] || @font_size
+      @terminal_line_height = (@terminal_font_size * @workspace.settings["terminal"]["line_height"]).ceil
+      @terminal_cell_width = @cx.text_system&.layout_line("M", size: @terminal_font_size)&.width || @terminal_font_size * 0.6
+      columns = [(bounds.width - 24) / @terminal_cell_width, @workspace.settings["terminal"]["min_cols"]].max.floor
+      rows = [(bounds.height - 40) / @terminal_line_height, @workspace.settings["terminal"]["min_rows"]].max.floor
+      @workspace.resize_terminal(columns, rows)
       grid = terminal.grid
-      @terminal_bounds = Zaniah::Bounds.new(bounds.x + 12, bounds.y + 28, columns * @terminal_cell_width, rows * @line_height)
+      @terminal_bounds = Zaniah::Bounds.new(bounds.x + 12, bounds.y + 32, columns * @terminal_cell_width, rows * @terminal_line_height).intersect(bounds)
       @terminal_scroll = (@terminal_scroll || 0).clamp(0, grid.scrollback.length)
       @terminal_first = grid.scrollback.length - @terminal_scroll.floor
       selection = @terminal_selection&.sort
@@ -153,11 +174,11 @@ module Canopus
           cells = terminal_row(@terminal_first + row)
           cells.each_with_index do |cell, column|
             next if cell.width.zero?
-            x, y = @terminal_bounds.x + column * @terminal_cell_width, @terminal_bounds.y + row * @line_height
+            x, y = @terminal_bounds.x + column * @terminal_cell_width, @terminal_bounds.y + row * @terminal_line_height
             foreground = terminal_color(cell.foreground, :foreground)
             background = terminal_color(cell.background, :panel)
             foreground, background = background, foreground if cell.attributes[:inverse]
-            rect = Zaniah::Bounds.new(x, y, cell.width * @terminal_cell_width, @line_height)
+            rect = Zaniah::Bounds.new(x, y, cell.width * @terminal_cell_width, @terminal_line_height)
             fill(rect, background) if background != @theme[:panel]
             position = [@terminal_first + row, column]
             fill(rect, :selection) if selection && (position <=> selection.first) >= 0 && (position <=> selection.last) <= 0
@@ -165,20 +186,39 @@ module Canopus
             foreground = Zaniah::Color.parse(foreground).opacity(0.6) if cell.attributes[:dim]
             unless cell.text.strip.empty?
               font = terminal_font(cell)
-              text(cell.text, x, y, color: foreground, font: font)
-              text(cell.text, x + 0.5, y, color: foreground, font: font) if cell.attributes[:bold]
+              text(cell.text, x, y, color: foreground, size: @terminal_font_size, font: font)
+              text(cell.text, x + 0.5, y, color: foreground, size: @terminal_font_size, font: font) if cell.attributes[:bold]
             end
             if cell.attributes[:underline] || cell.hyperlink
-              fill(Zaniah::Bounds.new(x, y + @line_height - 2, rect.width, 1), terminal_color(cell.attributes[:underline_color], :foreground))
+              fill(Zaniah::Bounds.new(x, y + @terminal_line_height - 2, rect.width, 1), terminal_color(cell.attributes[:underline_color], :foreground))
             end
-            fill(Zaniah::Bounds.new(x, y + @line_height / 2, rect.width, 1), foreground) if cell.attributes[:strikethrough]
+            fill(Zaniah::Bounds.new(x, y + @terminal_line_height / 2, rect.width, 1), foreground) if cell.attributes[:strikethrough]
           end
         end
-        if grid.cursor_visible && @terminal_scroll.zero?
-          fill(Zaniah::Bounds.new(@terminal_bounds.x + grid.cursor_x * @terminal_cell_width,
-            @terminal_bounds.y + grid.cursor_y * @line_height, @terminal_cell_width, @line_height), "#e9a66166")
+        blinking = @workspace.settings["terminal"]["blinking"]
+        if grid.cursor_visible && @terminal_scroll.zero? &&
+            (blinking == "off" || @cursor_visible || !@workspace.terminal_composition&.text.to_s.empty?)
+          x = @terminal_bounds.x + grid.cursor_x * @terminal_cell_width
+          y = @terminal_bounds.y + grid.cursor_y * @terminal_line_height
+          cursor = case @workspace.settings["terminal"]["cursor_shape"]
+          when "bar" then Zaniah::Bounds.new(x, y, 2, @terminal_line_height)
+          when "underline" then Zaniah::Bounds.new(x, y + @terminal_line_height - 2, @terminal_cell_width, 2)
+          else Zaniah::Bounds.new(x, y, @terminal_cell_width, @terminal_line_height)
+          end
+          fill(cursor, "#e9a66166")
+          composition = @workspace.terminal_composition
+          if composition && !composition.text.empty?
+            layout = text(composition.text, x, y, color: :accent, size: @terminal_font_size)
+            fill(Zaniah::Bounds.new(x, y + @terminal_line_height - 2, layout&.width || 20, 1), :accent)
+            @cx.window.ime_state = Zaniah::Bounds.new(x, y, 2, @terminal_line_height)
+          end
         end
       end
+      if terminal.respond_to?(:status) && terminal.status
+        code = terminal.status.exited? ? terminal.status.exitstatus : "signal #{terminal.status.termsig}"
+        text("Process exited with #{code} — press Enter to restart", @terminal_bounds.x + 4,
+          [@terminal_bounds.bottom - @terminal_line_height, @terminal_bounds.y].max, color: :muted, size: 11)
+      end
       region(@terminal_bounds, role: :terminal, label: "Terminal", action: [:terminal])
     end
   end

data/lib/canopus/workspace/view.rb

@@ -170,7 +170,7 @@ module Canopus
         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]
+        key = [name, @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
@@ -219,11 +219,19 @@ module Canopus
           end
           text(name, x + 14, bounds.y + 10, color: pane.active.equal?(editor) ? :foreground : :muted, size: 12)
           region(tab, role: :tab, label: name, action: [:tab, pane, editor])
+          close = Zaniah::Bounds.new(tab.right - 26, tab.y, 26, tab.height)
+          text(editor.buffer.dirty? ? "●" : "×", close.x + 6, close.y + 9, color: :muted, size: 12)
+          region(close, role: :button, label: "Close #{name}", action: [:tab_close, pane, editor])
           x += width
         end
       end
       editor = pane.active
-      return unless editor
+      unless editor
+        text("Open a file or create a new one", bounds.x + 24, bounds.y + 58, color: :muted, size: 14)
+        text("Cmd/Ctrl+P  Open    Cmd/Ctrl+N  New", bounds.x + 24, bounds.y + 84, color: :muted, size: 11)
+        fill(Zaniah::Bounds.new(bounds.right - 1, bounds.y, 1, bounds.height), :border)
+        return
+      end
       area = Zaniah::Bounds.new(bounds.x, bounds.y + 34, bounds.width, [bounds.height - 34, 0].max)
       @editor_bounds[editor] = area
       region(area, role: :textbox, label: editor.buffer.path || "Untitled document", action: [:editor, pane, editor])
@@ -236,7 +244,7 @@ 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
-      hunks = @workspace.git_hunks(editor.buffer)
+      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
@@ -280,9 +288,12 @@ module Canopus
           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 = hunks.find { |hunk| (source_row + 1).between?([hunk.new_start, 1].max, [hunk.new_start + hunk.new_count - 1, hunk.new_start].max) }
+          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.new_count.zero? ? @theme[:error] : change.old_count.zero? ? "#80b987" : @theme[:accent]
+            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
           end
@@ -327,9 +338,9 @@ 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, hunks)
+      paint_scrollbars(editor, bounds, measured_width, marks)
     end
-    def paint_scrollbars(editor, bounds, content_width, hunks)
+    def paint_scrollbars(editor, bounds, content_width, marks)
       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
@@ -337,8 +348,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)
-        hunks.first(500).each do |hunk|
-          y = track.y + track.height * [hunk.new_start - 1, 0].max / [editor.buffer.line_count, 1].max
+        marks.first(500).each do |mark|
+          y = track.y + track.height * [mark.new_line - 1, 0].max / [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|
@@ -576,7 +587,8 @@ module Canopus
     end
     def shortcut_labels
       return {} unless @keymap
-      context = {"Editor" => true, "vim_mode" => @workspace.settings["vim_mode"] ? @workspace.vim.mode.to_s : false}
+      context = {"Editor" => !!@workspace.editor,
+        "vim_mode" => @workspace.settings["vim_mode"] && @workspace.editor ? @workspace.vim.mode.to_s : false}
       seen, labels = {}, {}
       @keymap.bindings.reverse_each do |binding|
         next unless binding.predicate.call(context)