mui 0.1.0 → 0.3.0

data/lib/mui/editor.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+module Mui
+  # Main editor class that coordinates all components
+  class Editor
+    attr_reader :tab_manager, :undo_manager, :autocmd, :command_registry, :job_manager, :color_scheme, :floating_window,
+                :insert_completion_state, :key_sequence_handler
+    attr_accessor :message, :running
+
+    def initialize(file_path = nil, adapter: TerminalAdapter::Curses.new, load_config: true)
+      Mui.load_config if load_config
+
+      @adapter = adapter
+      @color_manager = ColorManager.new
+      @adapter.color_resolver = @color_manager
+      @color_scheme = load_color_scheme
+      @screen = Screen.new(adapter: @adapter, color_manager: @color_manager)
+      @input = Input.new(adapter: @adapter)
+      @buffer = Buffer.new
+      @buffer.load(file_path) if file_path
+
+      @tab_manager = TabManager.new(@screen, color_scheme: @color_scheme)
+      initial_tab = @tab_manager.add
+      initial_tab.window_manager.add_window(@buffer)
+
+      @tab_bar_renderer = TabBarRenderer.new(@tab_manager, color_scheme: @color_scheme)
+
+      @command_line = CommandLine.new
+      @completion_renderer = CompletionRenderer.new(@screen, @color_scheme)
+      @insert_completion_renderer = InsertCompletionRenderer.new(@screen, @color_scheme)
+      @floating_window = FloatingWindow.new(@color_scheme)
+      @message = nil
+      @running = true
+
+      @undo_manager = UndoManager.new
+      @buffer.undo_manager = @undo_manager
+
+      @autocmd = Autocmd.new
+      @command_registry = CommandRegistry.new
+      @job_manager = JobManager.new(autocmd: @autocmd)
+      @insert_completion_state = InsertCompletionState.new
+
+      # Install and load plugins via bundler/inline
+      Mui.plugin_manager.install_and_load
+
+      # Load plugin autocmds
+      load_plugin_autocmds
+
+      # Initialize key sequence handler for multi-key mappings
+      @key_sequence_handler = KeySequenceHandler.new(Mui.config)
+      @key_sequence_handler.rebuild_keymaps
+
+      @mode_manager = ModeManager.new(
+        window: @tab_manager,
+        buffer: @buffer,
+        command_line: @command_line,
+        undo_manager: @undo_manager,
+        editor: self,
+        key_sequence_handler: @key_sequence_handler
+      )
+
+      # Trigger BufEnter event
+      trigger_autocmd(:BufEnter)
+    end
+
+    def window_manager
+      @tab_manager.window_manager
+    end
+
+    def window
+      @tab_manager.active_window
+    end
+
+    def buffer
+      window.buffer
+    end
+
+    def mode
+      @mode_manager.mode
+    end
+
+    def selection
+      @mode_manager.selection
+    end
+
+    def register
+      @mode_manager.register
+    end
+
+    def run
+      while @running
+        process_job_results
+        check_key_sequence_timeout
+        update_window_size
+        render
+        key = @input.read_nonblock
+        if key
+          handle_key(key)
+        else
+          sleep 0.01 # CPU usage optimization
+        end
+      end
+    ensure
+      @adapter.close
+    end
+
+    # Open a scratch buffer (read-only) with the given content
+    def open_scratch_buffer(name, content)
+      scratch_buffer = Buffer.new(name)
+      scratch_buffer.content = content
+      scratch_buffer.readonly = true
+
+      # Split horizontally and show the scratch buffer
+      window_manager.split_horizontal(scratch_buffer)
+    end
+
+    # Update existing scratch buffer or create new one
+    def update_or_create_scratch_buffer(name, content)
+      existing = find_scratch_buffer(name)
+
+      if existing
+        existing.content = content
+        focus_buffer(existing)
+      else
+        open_scratch_buffer(name, content)
+      end
+    end
+
+    # Find a scratch buffer by name across all tabs and windows
+    def find_scratch_buffer(name)
+      @tab_manager.tabs.each do |tab|
+        tab.window_manager.windows.each do |win|
+          return win.buffer if win.buffer.name == name && win.buffer.readonly?
+        end
+      end
+      nil
+    end
+
+    # Focus a specific buffer by switching to its window
+    def focus_buffer(target_buffer)
+      @tab_manager.tabs.each_with_index do |tab, tab_index|
+        tab.window_manager.windows.each do |win|
+          next unless win.buffer == target_buffer
+
+          @tab_manager.go_to(tab_index)
+          tab.window_manager.focus_window(win)
+          return true
+        end
+      end
+      false
+    end
+
+    # Suspend UI for running external interactive commands (e.g., fzf)
+    def suspend_ui
+      @adapter.suspend
+      yield
+    ensure
+      @adapter.resume
+    end
+
+    def handle_key(key)
+      @message = nil
+
+      # Close floating window on Escape or any key input (except scroll keys if we add them)
+      if @floating_window.visible
+        @floating_window.hide
+        return if key == KeyCode::ESCAPE
+      end
+
+      old_window = window
+      old_buffer = old_window&.buffer
+      old_modified = old_buffer&.modified
+      result = @mode_manager.current_handler.handle(key)
+      apply_result(result)
+
+      current_window = window
+      return unless current_window # Guard against nil window (e.g., after closing last tab)
+
+      current_buffer = current_window.buffer
+
+      # Trigger BufEnter if buffer changed (window focus change)
+      trigger_autocmd(:BufEnter) if current_buffer != old_buffer
+
+      # Trigger TextChanged if buffer was modified
+      trigger_autocmd(:TextChanged) if (current_buffer.modified && !old_modified) || buffer_content_changed?
+    end
+
+    # Trigger autocmd event with current context
+    def trigger_autocmd(event)
+      context = CommandContext.new(editor: self, buffer:, window:)
+      @autocmd.trigger(event, context)
+    end
+
+    # Show a floating window with content at the cursor position
+    def show_floating(content, max_width: nil, max_height: nil)
+      # Position below cursor
+      row = window.screen_cursor_y + 1
+      col = window.screen_cursor_x
+
+      @floating_window.show(
+        content,
+        row:,
+        col:,
+        max_width: max_width || (@screen.width / 2),
+        max_height: max_height || 10
+      )
+    end
+
+    # Hide the floating window
+    def hide_floating
+      @floating_window.hide
+    end
+
+    # Start insert mode completion with LSP items
+    def start_insert_completion(items, prefix: "")
+      @insert_completion_state.start(items, prefix:)
+    end
+
+    # Check if insert completion is active
+    def insert_completion_active?
+      @insert_completion_state.active?
+    end
+
+    private
+
+    def buffer_content_changed?
+      # Track if content actually changed (for TextChanged event)
+      # Use change_count instead of hash for O(1) performance
+      @last_change_count ||= buffer.change_count
+      current_count = buffer.change_count
+      changed = @last_change_count != current_count
+      @last_change_count = current_count
+      changed
+    end
+
+    def update_window_size
+      window_manager.update_layout(y_offset: tab_bar_height)
+    end
+
+    def render
+      @screen.clear
+
+      @tab_bar_renderer.render(@screen, 0)
+
+      window.ensure_cursor_visible
+      window_manager.render_all(
+        @screen,
+        selection: @mode_manager.selection,
+        search_state: @mode_manager.search_state
+      )
+
+      render_status_area
+
+      # Position cursor based on current mode
+      if @mode_manager.mode == Mode::COMMAND
+        # In command mode, cursor is on the command line (after ":" + buffer position)
+        @screen.move_cursor(@screen.height - 1, 1 + @command_line.cursor_pos)
+      elsif [Mode::SEARCH_FORWARD, Mode::SEARCH_BACKWARD].include?(@mode_manager.mode)
+        # In search mode, cursor is on the search input line (after "/" or "?" + pattern)
+        @screen.move_cursor(@screen.height - 1, 1 + @mode_manager.search_input.buffer.length)
+      else
+        # In other modes, cursor is in the editor window
+        @screen.move_cursor(window.screen_cursor_y, window.screen_cursor_x)
+      end
+      @screen.refresh
+    end
+
+    def tab_bar_height
+      @tab_bar_renderer.height
+    end
+
+    def render_status_area
+      status_text = case @mode_manager.mode
+                    when Mode::COMMAND
+                      @command_line.to_s
+                    when Mode::INSERT
+                      @message || "-- INSERT --"
+                    when Mode::VISUAL
+                      @message || "-- VISUAL --"
+                    when Mode::VISUAL_LINE
+                      @message || "-- VISUAL LINE --"
+                    when Mode::SEARCH_FORWARD, Mode::SEARCH_BACKWARD
+                      @mode_manager.search_input.to_s
+                    else
+                      @message || "-- NORMAL --"
+                    end
+
+      status_line = status_text.ljust(@screen.width)
+      style = @color_scheme[:command_line]
+      @screen.put_with_style(@screen.height - 1, 0, status_line, style)
+
+      # Render completion popup based on mode
+      if @mode_manager.mode == Mode::COMMAND
+        render_completion_popup
+      elsif [Mode::SEARCH_FORWARD, Mode::SEARCH_BACKWARD].include?(@mode_manager.mode)
+        render_search_completion_popup
+      elsif @mode_manager.mode == Mode::INSERT
+        render_insert_completion_popup
+      end
+
+      # Render floating window if visible
+      @floating_window.render(@screen)
+    end
+
+    def render_search_completion_popup
+      completion_state = @mode_manager.current_handler.completion_state
+      return unless completion_state&.active?
+
+      # Popup appears above the search line, starting after "/" or "?"
+      base_row = @screen.height - 1
+      base_col = 1 # After the prompt
+      @completion_renderer.render(completion_state, base_row, base_col)
+    end
+
+    def render_completion_popup
+      completion_state = @mode_manager.current_handler.completion_state
+      return unless completion_state&.active?
+
+      # Popup appears above the command line, starting after the ":"
+      base_row = @screen.height - 1
+      base_col = 1 # After the ":"
+      @completion_renderer.render(completion_state, base_row, base_col)
+    end
+
+    def render_insert_completion_popup
+      return unless @insert_completion_state&.active?
+
+      # Popup appears below the cursor
+      @insert_completion_renderer.render(
+        @insert_completion_state,
+        window.screen_cursor_y,
+        window.screen_cursor_x
+      )
+    end
+
+    def apply_result(result)
+      @mode_manager.transition(result)
+      @message = result.message if result.message
+      @running = false if result.quit?
+    end
+
+    def load_color_scheme
+      scheme_name = Mui.config.get(:colorscheme)
+      Themes.send(scheme_name.to_sym)
+    rescue NoMethodError
+      Themes.mui
+    end
+
+    def load_plugin_autocmds
+      Mui.config.autocmds.each do |event, handlers|
+        handlers.each do |h|
+          @autocmd.register(event, pattern: h[:pattern], &h[:handler])
+        end
+      end
+    end
+
+    def process_job_results
+      @job_manager.poll
+    end
+
+    def check_key_sequence_timeout
+      return unless @key_sequence_handler.pending?
+
+      mode_symbol = mode_to_symbol(@mode_manager.mode)
+      result = @key_sequence_handler.check_timeout(mode_symbol)
+
+      return unless result
+
+      type, data = result
+      case type
+      when KeySequenceHandler::RESULT_HANDLED
+        execute_keymap_handler(data)
+      when KeySequenceHandler::RESULT_PASSTHROUGH
+        # Re-process the passthrough key
+        handle_key(data) if data
+      end
+    end
+
+    def mode_to_symbol(mode)
+      case mode
+      when Mode::NORMAL then :normal
+      when Mode::INSERT then :insert
+      when Mode::VISUAL, Mode::VISUAL_LINE then :visual
+      when Mode::COMMAND then :command
+      when Mode::SEARCH_FORWARD, Mode::SEARCH_BACKWARD then :search
+      else :normal
+      end
+    end
+
+    def execute_keymap_handler(handler)
+      context = CommandContext.new(editor: self, buffer:, window:)
+      handler.call(context)
+    end
+  end
+end

data/lib/mui/error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mui
+  class Error < StandardError; end
+
+  # Raised when a subclass does not override a required method
+  class MethodNotOverriddenError < Error
+    def initialize(method_name)
+      super("Subclass must implement ##{method_name}")
+    end
+  end
+
+  # Raised when a plugin operation fails
+  class PluginError < Error; end
+
+  # Raised when a plugin is not found
+  class PluginNotFoundError < PluginError
+    def initialize(plugin_name)
+      super("Plugin '#{plugin_name}' not found")
+    end
+  end
+
+  # Raised when an unknown command is executed
+  class UnknownCommandError < Error
+    def initialize(command_name)
+      super("Unknown command: #{command_name}")
+    end
+  end
+end

data/lib/mui/file_completer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Mui
+  # Provides file path completion
+  class FileCompleter
+    def complete(partial_path)
+      return list_current_directory if partial_path.empty?
+
+      dir, prefix = split_path(partial_path)
+      entries = list_directory(dir)
+
+      entries.select { |entry| entry.start_with?(prefix) }
+             .map { |entry| join_path(dir, entry) }
+             .map { |path| format_path(path) }
+    end
+
+    private
+
+    def split_path(path)
+      if path.end_with?("/")
+        [path, ""]
+      else
+        dir = File.dirname(path)
+        dir = "" if dir == "."
+        [dir, File.basename(path)]
+      end
+    end
+
+    def list_directory(dir)
+      target = dir.empty? ? "." : dir
+      return [] unless Dir.exist?(target)
+
+      Dir.entries(target)
+         .reject { |e| e.start_with?(".") }
+         .sort
+    end
+
+    def list_current_directory
+      list_directory("").map { |entry| format_path(entry) }
+    end
+
+    def join_path(dir, entry)
+      dir.empty? ? entry : File.join(dir, entry)
+    end
+
+    def format_path(path)
+      full_path = path.start_with?("/") ? path : File.join(".", path)
+      File.directory?(full_path) ? "#{path}/" : path
+    end
+  end
+end

data/lib/mui/floating_window.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Mui
+  # A floating window (popup) for displaying temporary content like hover info
+  class FloatingWindow
+    attr_reader :content, :row, :col, :width, :height
+    attr_accessor :visible
+
+    def initialize(color_scheme)
+      @color_scheme = color_scheme
+      @content = []
+      @row = 0
+      @col = 0
+      @width = 0
+      @height = 0
+      @visible = false
+      @scroll_offset = 0
+    end
+
+    # Show the floating window with content at the specified position
+    def show(content, row:, col:, max_width: nil, max_height: nil)
+      @content = normalize_content(content)
+      @row = row
+      @col = col
+      @max_width = max_width
+      @max_height = max_height
+      @scroll_offset = 0
+      calculate_dimensions
+      @visible = true
+    end
+
+    # Hide the floating window
+    def hide
+      @visible = false
+      @content = []
+    end
+
+    # Scroll content up
+    def scroll_up
+      @scroll_offset = [@scroll_offset - 1, 0].max if @visible
+    end
+
+    # Scroll content down
+    def scroll_down
+      max_offset = [@content.length - @height, 0].max
+      @scroll_offset = [@scroll_offset + 1, max_offset].min if @visible
+    end
+
+    # Render the floating window to the screen
+    def render(screen)
+      return unless @visible
+      return if @content.empty?
+
+      # Adjust position to fit within screen bounds
+      adjusted_row, adjusted_col = adjust_position(screen)
+
+      # Draw border and content
+      draw_border(screen, adjusted_row, adjusted_col)
+      draw_content(screen, adjusted_row, adjusted_col)
+    end
+
+    private
+
+    def normalize_content(content)
+      case content
+      when String
+        content.split("\n")
+      when Array
+        content.flat_map { |line| line.to_s.split("\n") }
+      else
+        [content.to_s]
+      end
+    end
+
+    def calculate_dimensions
+      return if @content.empty?
+
+      # Calculate content dimensions
+      content_width = @content.map { |line| UnicodeWidth.string_width(line) }.max || 0
+      content_height = @content.length
+
+      # Apply max constraints (+2 for border)
+      @width = content_width + 2
+      @width = [@width, @max_width].min if @max_width
+
+      @height = content_height + 2
+      @height = [@height, @max_height].min if @max_height
+    end
+
+    def adjust_position(screen)
+      row = @row
+      col = @col
+
+      # Adjust horizontal position
+      col = screen.width - @width if col + @width > screen.width
+      col = [col, 0].max
+
+      # Adjust vertical position - prefer below cursor, but go above if not enough space
+      if row + @height > screen.height
+        # Try above the original position
+        row = @row - @height
+      end
+      row = [row, 0].max
+
+      [row, col]
+    end
+
+    def draw_border(screen, row, col)
+      style = @color_scheme[:floating_window] || @color_scheme[:completion_popup]
+
+      # Top border
+      top_border = "┌#{"─" * (@width - 2)}┐"
+      screen.put_with_style(row, col, top_border, style)
+
+      # Side borders
+      inner_height = @height - 2
+      inner_height.times do |i|
+        screen.put_with_style(row + 1 + i, col, "│", style)
+        screen.put_with_style(row + 1 + i, col + @width - 1, "│", style)
+      end
+
+      # Bottom border
+      bottom_border = "└#{"─" * (@width - 2)}┘"
+      screen.put_with_style(row + @height - 1, col, bottom_border, style)
+    end
+
+    def draw_content(screen, row, col)
+      style = @color_scheme[:floating_window] || @color_scheme[:completion_popup]
+      inner_width = @width - 2
+      inner_height = @height - 2
+
+      inner_height.times do |i|
+        line_index = @scroll_offset + i
+        line = @content[line_index] || ""
+
+        # Truncate line if needed
+        display_line = truncate_to_width(line, inner_width)
+        padded_line = display_line.ljust(inner_width)
+
+        screen.put_with_style(row + 1 + i, col + 1, padded_line, style)
+      end
+    end
+
+    def truncate_to_width(text, max_width)
+      return text if UnicodeWidth.string_width(text) <= max_width
+
+      result = ""
+      current_width = 0
+
+      text.each_char do |char|
+        char_width = UnicodeWidth.char_width(char)
+        break if current_width + char_width > max_width
+
+        result += char
+        current_width += char_width
+      end
+
+      result
+    end
+  end
+end