mui 0.1.0 → 0.3.0

data/lib/mui/command_context.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Mui
+  # Provides plugin access to editor internals
+  class CommandContext
+    attr_reader :buffer, :window, :editor
+
+    def initialize(editor:, buffer:, window:)
+      @editor = editor
+      @buffer = buffer
+      @window = window
+    end
+
+    def cursor
+      { line: @buffer.cursor_y, col: @buffer.cursor_x }
+    end
+
+    def current_line
+      @buffer.current_line
+    end
+
+    def insert(text)
+      @buffer.insert_text(text)
+    end
+
+    def set_message(msg)
+      @editor.message = msg
+    end
+
+    def quit
+      @editor.running = false
+    end
+
+    def run_command(name, *)
+      @editor.command_registry.execute(name, self, *)
+    end
+
+    def run_async(on_complete: nil, &)
+      @editor.job_manager.run_async(on_complete:, &)
+    end
+
+    def run_shell_command(cmd, on_complete: nil)
+      @editor.job_manager.run_command(cmd, on_complete:)
+    end
+
+    def jobs_running?
+      @editor.job_manager.busy?
+    end
+
+    def cancel_job(id)
+      @editor.job_manager.cancel(id)
+    end
+
+    def open_scratch_buffer(name, content)
+      @editor.open_scratch_buffer(name, content)
+    end
+
+    # Run an interactive command that needs terminal access (e.g., fzf)
+    # Suspends Curses UI, runs command, resumes UI
+    def run_interactive_command(cmd)
+      require "tempfile"
+
+      @editor.suspend_ui do
+        output_file = Tempfile.new("mui_interactive")
+        begin
+          # Use shell redirection to capture output while keeping stdin/stderr connected to terminal
+          # rubocop:disable Style/SpecialGlobalVars
+          success = system("#{cmd} > #{output_file.path}")
+          status = $?
+          # rubocop:enable Style/SpecialGlobalVars
+          exit_status = status&.exitstatus || 1
+          {
+            stdout: File.read(output_file.path),
+            stderr: "",
+            exit_status:,
+            success: success == true && exit_status.zero?
+          }
+        ensure
+          output_file.close
+          output_file.unlink
+        end
+      end
+    end
+
+    # Check if a command exists in PATH
+    def command_exists?(cmd)
+      system("which #{cmd} > /dev/null 2>&1")
+    end
+  end
+end

data/lib/mui/command_history.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages command history with file persistence
+  class CommandHistory
+    MAX_HISTORY = 100
+    HISTORY_FILE = File.expand_path("~/.mui_history")
+
+    attr_reader :history
+
+    def initialize(history_file: HISTORY_FILE)
+      @history_file = history_file
+      @history = []
+      @index = nil
+      @saved_input = nil
+      load_from_file
+    end
+
+    def add(command)
+      return if command.strip.empty?
+
+      @history.delete(command)
+      @history.push(command)
+      @history.shift if @history.size > MAX_HISTORY
+      save_to_file
+    end
+
+    def previous(current_input)
+      return nil if @history.empty?
+
+      if @index.nil?
+        @saved_input = current_input
+        @index = @history.size - 1
+      elsif @index.positive?
+        @index -= 1
+      else
+        return nil
+      end
+
+      @history[@index]
+    end
+
+    def next_entry
+      return nil if @index.nil?
+
+      if @index < @history.size - 1
+        @index += 1
+        @history[@index]
+      else
+        result = @saved_input
+        reset
+        result
+      end
+    end
+
+    def reset
+      @index = nil
+      @saved_input = nil
+    end
+
+    def browsing?
+      !@index.nil?
+    end
+
+    def size
+      @history.size
+    end
+
+    def empty?
+      @history.empty?
+    end
+
+    private
+
+    def load_from_file
+      return unless File.exist?(@history_file)
+
+      @history = File.readlines(@history_file, chomp: true).last(MAX_HISTORY)
+    rescue StandardError
+      @history = []
+    end
+
+    def save_to_file
+      File.write(@history_file, "#{@history.join("\n")}\n")
+    rescue StandardError
+      # Ignore write failures
+    end
+  end
+end

data/lib/mui/command_line.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Mui
+  class CommandLine
+    # Commands that accept file path arguments
+    FILE_COMMANDS = %w[e w sp split vs vsplit tabnew tabe tabedit].freeze
+
+    attr_reader :buffer, :cursor_pos, :history
+
+    def initialize(history: CommandHistory.new)
+      @buffer = ""
+      @cursor_pos = 0
+      @history = history
+    end
+
+    def input(char)
+      @buffer = @buffer[0...@cursor_pos].to_s + char + @buffer[@cursor_pos..].to_s
+      @cursor_pos += char.length
+    end
+
+    def backspace
+      return if @cursor_pos.zero?
+
+      @buffer = @buffer[0...(@cursor_pos - 1)].to_s + @buffer[@cursor_pos..].to_s
+      @cursor_pos -= 1
+    end
+
+    def clear
+      @buffer = ""
+      @cursor_pos = 0
+      @history.reset
+    end
+
+    def history_previous
+      result = @history.previous(@buffer)
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
+    end
+
+    def history_next
+      result = @history.next_entry
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
+    end
+
+    def move_cursor_left
+      @cursor_pos -= 1 if @cursor_pos.positive?
+    end
+
+    def move_cursor_right
+      @cursor_pos += 1 if @cursor_pos < @buffer.length
+    end
+
+    def execute
+      command = @buffer.strip
+      @history.add(command) unless command.empty?
+      @history.reset
+      result = parse(@buffer)
+      @buffer = ""
+      @cursor_pos = 0
+      result
+    end
+
+    def to_s
+      ":#{@buffer}"
+    end
+
+    # Determine completion context based on current buffer
+    def completion_context
+      # Check if buffer contains a space (command + argument)
+      if @buffer.include?(" ")
+        # Command with argument
+        parts = @buffer.split(/\s+/, 2)
+        command = parts[0]
+        arg = parts[1] || ""
+
+        return { type: :file, command:, prefix: arg } if FILE_COMMANDS.include?(command)
+
+        # Return nil for commands that don't support file completion
+        return nil
+      end
+
+      # No space -> command completion
+      { type: :command, prefix: @buffer.strip }
+    end
+
+    # Apply completion result to buffer
+    def apply_completion(text, context)
+      @buffer = if context[:type] == :command
+                  text
+                else
+                  "#{context[:command]} #{text}"
+                end
+      @cursor_pos = @buffer.length
+    end
+
+    private
+
+    def parse(cmd)
+      case cmd.strip
+      when ""
+        { action: :no_op }
+      when "e"
+        { action: :open }
+      when /^e\s+(.+)/
+        { action: :open_as, path: ::Regexp.last_match(1) }
+      when "w"
+        { action: :write }
+      when "q"
+        { action: :quit }
+      when "wq"
+        { action: :write_quit }
+      when "q!"
+        { action: :force_quit }
+      when /^w\s+(.+)/
+        { action: :write_as, path: ::Regexp.last_match(1) }
+      when "sp", "split"
+        { action: :split_horizontal }
+      when /^sp\s+(.+)/, /^split\s+(.+)/
+        { action: :split_horizontal, path: ::Regexp.last_match(1) }
+      when "vs", "vsplit"
+        { action: :split_vertical }
+      when /^vs\s+(.+)/, /^vsplit\s+(.+)/
+        { action: :split_vertical, path: ::Regexp.last_match(1) }
+      when "close"
+        { action: :close_window }
+      when "only"
+        { action: :only_window }
+      when "tabnew", "tabe", "tabedit"
+        { action: :tab_new }
+      when /^tabnew\s+(.+)/, /^tabe\s+(.+)/, /^tabedit\s+(.+)/
+        { action: :tab_new, path: ::Regexp.last_match(1) }
+      when "tabclose", "tabc"
+        { action: :tab_close }
+      when "tabnext", "tabn"
+        { action: :tab_next }
+      when "tabprev", "tabp", "tabprevious"
+        { action: :tab_prev }
+      when "tabfirst", "tabf", "tabrewind", "tabr"
+        { action: :tab_first }
+      when "tablast", "tabl"
+        { action: :tab_last }
+      when /^tabmove\s+(\d+)/, /^tabm\s+(\d+)/
+        { action: :tab_move, position: ::Regexp.last_match(1).to_i }
+      when /^(\d+)tabn(?:ext)?/, /^tabn(?:ext)?\s+(\d+)/
+        { action: :tab_go, index: ::Regexp.last_match(1).to_i - 1 }
+      when /^!(.*)$/
+        shell_cmd = ::Regexp.last_match(1).strip
+        if shell_cmd.empty?
+          { action: :shell_command_error, message: "E471: Argument required" }
+        else
+          { action: :shell_command, command: shell_cmd }
+        end
+      when /^(\d+)$/
+        { action: :goto_line, line_number: ::Regexp.last_match(1).to_i }
+      else
+        { action: :unknown, command: cmd }
+      end
+    end
+  end
+end

data/lib/mui/command_registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mui
+  # Registry for Ex commands
+  class CommandRegistry
+    def initialize
+      @commands = {}
+    end
+
+    def register(name, &block)
+      @commands[name.to_sym] = block
+    end
+
+    def execute(name, context, *)
+      command = find(name)
+      raise UnknownCommandError, name unless command
+
+      command.call(context, *)
+    end
+
+    def exists?(name)
+      @commands.key?(name.to_sym) || plugin_command_exists?(name)
+    end
+
+    def find(name)
+      # Built-in commands take precedence
+      command = @commands[name.to_sym]
+      return command if command
+
+      # Fall back to plugin commands
+      plugin_commands[name.to_sym]
+    end
+
+    private
+
+    def plugin_command_exists?(name)
+      plugin_commands.key?(name.to_sym)
+    end
+
+    def plugin_commands
+      Mui.config.commands
+    end
+  end
+end

data/lib/mui/completion_renderer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Mui
+  # Renders completion popup menu
+  class CompletionRenderer
+    MAX_VISIBLE_ITEMS = 10
+
+    def initialize(screen, color_scheme)
+      @screen = screen
+      @color_scheme = color_scheme
+    end
+
+    def render(completion_state, base_row, base_col)
+      return unless completion_state.active?
+
+      candidates = completion_state.candidates
+      selected_index = completion_state.selected_index
+
+      # Calculate visible window
+      visible_start, visible_end = calculate_visible_range(candidates.length, selected_index)
+      visible_candidates = candidates[visible_start...visible_end]
+
+      # Calculate popup dimensions
+      max_width = calculate_max_width(visible_candidates)
+      popup_height = visible_candidates.length
+
+      # Calculate position (popup appears above the command line)
+      popup_row = base_row - popup_height
+      popup_col = base_col
+
+      # Ensure popup stays within screen bounds
+      popup_col = [@screen.width - max_width - 1, popup_col].min
+      popup_col = [0, popup_col].max
+      popup_row = [0, popup_row].max
+
+      # Render each visible candidate
+      visible_candidates.each_with_index do |candidate, i|
+        actual_index = visible_start + i
+        is_selected = actual_index == selected_index
+
+        render_item(
+          candidate,
+          popup_row + i,
+          popup_col,
+          max_width,
+          is_selected
+        )
+      end
+    end
+
+    private
+
+    def calculate_visible_range(total_count, selected_index)
+      return [0, total_count] if total_count <= MAX_VISIBLE_ITEMS
+
+      # Try to center the selected item
+      half = MAX_VISIBLE_ITEMS / 2
+      start_index = selected_index - half
+      start_index = [0, start_index].max
+      end_index = start_index + MAX_VISIBLE_ITEMS
+      end_index = [total_count, end_index].min
+      start_index = end_index - MAX_VISIBLE_ITEMS
+
+      [start_index, end_index]
+    end
+
+    def calculate_max_width(candidates)
+      return 0 if candidates.empty?
+
+      candidates.map { |c| display_width(c) }.max + 2 # +2 for padding
+    end
+
+    def display_width(text)
+      UnicodeWidth.string_width(text)
+    end
+
+    def render_item(text, row, col, width, selected)
+      style_key = selected ? :completion_popup_selected : :completion_popup
+      style = @color_scheme[style_key]
+      padded_text = " #{text}".ljust(width)
+      @screen.put_with_style(row, col, padded_text, style)
+    end
+  end
+end

data/lib/mui/completion_state.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages completion popup state
+  class CompletionState
+    attr_reader :candidates, :selected_index, :original_input, :completion_type
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @candidates = []
+      @selected_index = 0
+      @original_input = nil
+      @completion_type = nil # :command or :file
+      @confirmed = false
+    end
+
+    def active?
+      !@candidates.empty?
+    end
+
+    def start(candidates, original_input, type)
+      @candidates = candidates
+      @selected_index = 0
+      @original_input = original_input
+      @completion_type = type
+      @confirmed = false
+    end
+
+    def confirm
+      @confirmed = true
+    end
+
+    def confirmed?
+      @confirmed
+    end
+
+    def select_next
+      return unless active?
+
+      @selected_index = (@selected_index + 1) % @candidates.length
+    end
+
+    def select_previous
+      return unless active?
+
+      @selected_index = (@selected_index - 1) % @candidates.length
+    end
+
+    def current_candidate
+      return nil unless active?
+
+      @candidates[@selected_index]
+    end
+  end
+end

data/lib/mui/config.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mui
+  class Config
+    attr_reader :options, :plugins, :keymaps, :commands, :autocmds
+
+    def initialize
+      @options = {
+        colorscheme: "mui",
+        syntax: true, # Enable/disable syntax highlighting
+        shiftwidth: 2, # Indent width for > and < commands
+        expandtab: true, # Use spaces instead of tabs
+        tabstop: 8, # Tab display width
+        reselect_after_indent: false, # Keep selection after > / < in visual mode
+        leader: "\\", # Leader key for key mappings (default: backslash)
+        timeoutlen: 1000 # Timeout for multi-key sequences in milliseconds
+      }
+      @plugins = []
+      @keymaps = {}
+      @commands = {}
+      @autocmds = {}
+    end
+
+    def set(key, value)
+      @options[key.to_sym] = value
+    end
+
+    def get(key)
+      @options[key.to_sym]
+    end
+
+    def load_file(path)
+      return unless File.exist?(path)
+
+      instance_eval(File.read(path), path)
+    end
+
+    # Stub for future plugin support
+    def use_plugin(gem_name, version = nil)
+      @plugins << { gem: gem_name, version: }
+    end
+
+    # Stub for future keymap support
+    def add_keymap(mode, key, block)
+      @keymaps[mode] ||= {}
+      @keymaps[mode][key] = block
+    end
+
+    def add_command(name, block)
+      @commands[name.to_sym] = block
+    end
+
+    def add_autocmd(event, pattern, block)
+      @autocmds[event.to_sym] ||= []
+      @autocmds[event.to_sym] << { pattern:, handler: block }
+    end
+  end
+end