mui 0.1.0 → 0.2.0

data/lib/mui/highlighters/search_highlighter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Mui
+  module Highlighters
+    class SearchHighlighter < Base
+      def highlights_for(row, _line, options = {})
+        search_state = options[:search_state]
+        return [] unless search_state&.has_pattern?
+
+        matches = search_state.matches_for_row(row)
+        matches.map do |match|
+          Highlight.new(
+            start_col: match[:col],
+            end_col: match[:end_col],
+            style: :search_highlight,
+            priority:
+          )
+        end
+      end
+
+      def priority
+        PRIORITY_SEARCH
+      end
+    end
+  end
+end

data/lib/mui/highlighters/selection_highlighter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Mui
+  module Highlighters
+    class SelectionHighlighter < Base
+      def highlights_for(row, line, options = {})
+        selection = options[:selection]
+        return [] unless selection
+
+        range = selection.normalized_range
+        return [] if row < range[:start_row] || row > range[:end_row]
+
+        if selection.line_mode
+          line_mode_highlights(line)
+        else
+          char_mode_highlights(row, line, range)
+        end
+      end
+
+      def priority
+        PRIORITY_SELECTION
+      end
+
+      private
+
+      def line_mode_highlights(line)
+        [Highlight.new(
+          start_col: 0,
+          end_col: [line.length - 1, 0].max,
+          style: :visual_selection,
+          priority:
+        )]
+      end
+
+      def char_mode_highlights(row, line, range)
+        start_col = row == range[:start_row] ? range[:start_col] : 0
+        end_col = row == range[:end_row] ? range[:end_col] : [line.length - 1, 0].max
+
+        [Highlight.new(
+          start_col:,
+          end_col:,
+          style: :visual_selection,
+          priority:
+        )]
+      end
+    end
+  end
+end

data/lib/mui/highlighters/syntax_highlighter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Mui
+  module Highlighters
+    # Provides syntax highlighting based on language-specific lexers
+    class SyntaxHighlighter < Base
+      # Maps token types to ColorScheme style names
+      # Note: identifier and operator are excluded to reduce highlight count
+      # (they typically use the same color as normal text)
+      TOKEN_STYLE_MAP = {
+        keyword: :syntax_keyword,
+        string: :syntax_string,
+        comment: :syntax_comment,
+        number: :syntax_number,
+        symbol: :syntax_symbol,
+        constant: :syntax_constant,
+        preprocessor: :syntax_preprocessor,
+        char: :syntax_string,
+        instance_variable: :syntax_instance_variable,
+        global_variable: :syntax_global_variable,
+        method_call: :syntax_method_call,
+        type: :syntax_type
+      }.freeze
+
+      def initialize(color_scheme, buffer: nil)
+        super(color_scheme)
+        @buffer = buffer
+        setup_lexer
+      end
+
+      # Update the buffer and reset the lexer
+      def buffer=(new_buffer)
+        @buffer = new_buffer
+        setup_lexer
+      end
+
+      # Generate highlights for a line
+      # TODO: Refactor to reduce complexity (Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity)
+      def highlights_for(row, line, options = {})
+        return [] unless @lexer
+        return [] unless Mui.config.get(:syntax)
+
+        buffer_lines = options[:buffer]&.lines || @buffer&.lines || []
+        tokens = @token_cache.tokens_for(row, line, buffer_lines)
+
+        tokens.filter_map do |token|
+          style = style_for_token_type(token.type)
+          next unless style && @color_scheme[style]
+
+          Highlight.new(
+            start_col: token.start_col,
+            end_col: token.end_col,
+            style:,
+            priority:
+          )
+        end
+      end
+
+      def priority
+        PRIORITY_SYNTAX
+      end
+
+      # Invalidate cache from a specific row onwards
+      # Called when buffer content changes
+      def invalidate_from(row)
+        @token_cache&.invalidate(row)
+      end
+
+      # Clear the entire cache
+      def clear_cache
+        @token_cache&.clear
+      end
+
+      # Prefetch tokens for lines around the visible area
+      def prefetch(visible_start, visible_end)
+        return unless @lexer && @token_cache && @buffer
+        return unless Mui.config.get(:syntax)
+
+        @token_cache.prefetch(visible_start, visible_end, @buffer.lines)
+      end
+
+      # Check if this highlighter is active (has a lexer)
+      def active?
+        !@lexer.nil?
+      end
+
+      private
+
+      def setup_lexer
+        @lexer = nil
+        @token_cache = nil
+        return unless @buffer
+
+        @lexer = Syntax::LanguageDetector.lexer_for_file(@buffer.name)
+        return unless @lexer
+
+        @token_cache = Syntax::TokenCache.new(@lexer)
+      end
+
+      def style_for_token_type(type)
+        TOKEN_STYLE_MAP[type]
+      end
+    end
+  end
+end

data/lib/mui/input.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mui
+  class Input
+    def initialize(adapter:)
+      @adapter = adapter
+    end
+
+    def read
+      @adapter.getch
+    end
+
+    def read_nonblock
+      @adapter.getch_nonblock
+    end
+  end
+end

data/lib/mui/insert_completion_renderer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Mui
+  # Renders completion popup for Insert mode (LSP completions)
+  class InsertCompletionRenderer
+    MAX_VISIBLE_ITEMS = 10
+
+    def initialize(screen, color_scheme)
+      @screen = screen
+      @color_scheme = color_scheme
+    end
+
+    def render(completion_state, cursor_row, cursor_col)
+      return unless completion_state.active?
+
+      items = completion_state.items
+      selected_index = completion_state.selected_index
+
+      # Calculate visible window
+      visible_start, visible_end = calculate_visible_range(items.length, selected_index)
+      visible_items = items[visible_start...visible_end]
+
+      # Calculate popup dimensions
+      max_width = calculate_max_width(visible_items)
+      popup_height = visible_items.length
+
+      # Calculate position (popup appears below the cursor)
+      popup_row = cursor_row + 1
+      popup_col = cursor_col
+
+      # If popup would go below screen, show above cursor instead
+      popup_row = cursor_row - popup_height if popup_row + popup_height > @screen.height - 1
+
+      # 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 item
+      visible_items.each_with_index do |item, i|
+        actual_index = visible_start + i
+        is_selected = actual_index == selected_index
+
+        render_item(
+          item,
+          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(items)
+      return 0 if items.empty?
+
+      items.map { |item| display_width(item_label(item)) }.max + 2 # +2 for padding
+    end
+
+    def item_label(item)
+      item[:label] || item.to_s
+    end
+
+    def display_width(text)
+      UnicodeWidth.string_width(text)
+    end
+
+    def render_item(item, row, col, width, selected)
+      style_key = selected ? :completion_popup_selected : :completion_popup
+      style = @color_scheme[style_key]
+      label = item_label(item)
+      padded_text = " #{label}".ljust(width)
+      @screen.put_with_style(row, col, padded_text, style)
+    end
+  end
+end

data/lib/mui/insert_completion_state.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages Insert mode completion state for LSP completions
+  class InsertCompletionState
+    attr_reader :items, :selected_index, :prefix, :original_items
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @items = []
+      @original_items = []
+      @selected_index = 0
+      @prefix = ""
+    end
+
+    def active?
+      !@items.empty?
+    end
+
+    def start(items, prefix: "")
+      @original_items = items.dup
+      @items = items
+      @selected_index = 0
+      @prefix = prefix
+    end
+
+    # Update prefix and filter items based on new prefix
+    def update_prefix(new_prefix)
+      return if new_prefix == @prefix
+
+      @prefix = new_prefix
+      @items = @original_items.select do |item|
+        label = item[:label] || item[:insert_text] || ""
+        label.downcase.start_with?(new_prefix.downcase)
+      end
+      @selected_index = 0
+    end
+
+    def select_next
+      return unless active?
+
+      @selected_index = (@selected_index + 1) % @items.length
+    end
+
+    def select_previous
+      return unless active?
+
+      @selected_index = (@selected_index - 1) % @items.length
+    end
+
+    def current_item
+      return nil unless active?
+
+      @items[@selected_index]
+    end
+
+    # Returns the text to insert for the current item
+    def insert_text
+      return nil unless current_item
+
+      item = current_item
+      # Prefer textEdit.newText if available (text_edit value has string keys from LSP)
+      item.dig(:text_edit, "newText") || item[:insert_text] || item[:label] || item.to_s
+    end
+
+    # Returns the textEdit range if available
+    def text_edit_range
+      return nil unless current_item
+
+      # text_edit value has string keys from LSP
+      current_item.dig(:text_edit, "range")
+    end
+  end
+end

data/lib/mui/job.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Mui
+  # Represents a single asynchronous job
+  class Job
+    # Job status constants
+    module Status
+      PENDING   = :pending
+      RUNNING   = :running
+      COMPLETED = :completed
+      FAILED    = :failed
+      CANCELLED = :cancelled
+    end
+
+    attr_reader :id, :status, :result, :error
+
+    def initialize(id, &block)
+      @id = id
+      @block = block
+      @status = Status::PENDING
+      @result = nil
+      @error = nil
+      @cancelled = false
+      @mutex = Mutex.new
+    end
+
+    def run
+      @mutex.synchronize do
+        return if @cancelled
+
+        @status = Status::RUNNING
+      end
+
+      begin
+        @result = @block.call
+        @mutex.synchronize do
+          @status = @cancelled ? Status::CANCELLED : Status::COMPLETED
+        end
+      rescue StandardError => e
+        @mutex.synchronize do
+          @error = e
+          @status = Status::FAILED
+        end
+      end
+    end
+
+    def cancel
+      @mutex.synchronize do
+        return false if @status == Status::COMPLETED || @status == Status::FAILED
+
+        @cancelled = true
+        @status = Status::CANCELLED if @status == Status::PENDING
+        true
+      end
+    end
+
+    def pending?
+      @status == Status::PENDING
+    end
+
+    def running?
+      @status == Status::RUNNING
+    end
+
+    def completed?
+      @status == Status::COMPLETED
+    end
+
+    def failed?
+      @status == Status::FAILED
+    end
+
+    def cancelled?
+      @status == Status::CANCELLED
+    end
+
+    def finished?
+      completed? || failed? || cancelled?
+    end
+  end
+end

data/lib/mui/job_manager.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mui
+  # Manages asynchronous job execution and result collection
+  class JobManager
+    def initialize(autocmd: nil)
+      @autocmd = autocmd
+      @result_queue = Queue.new
+      @next_id = 0
+      @id_mutex = Mutex.new
+      @active_jobs = {}
+      @jobs_mutex = Mutex.new
+    end
+
+    def run_async(on_complete: nil, &)
+      job = create_job(&)
+
+      Thread.new do
+        job.run
+        @result_queue.push({ job:, callback: on_complete })
+      end
+
+      job
+    end
+
+    def run_command(cmd, on_complete: nil)
+      run_async(on_complete:) do
+        stdout, stderr, status = Open3.capture3(*Array(cmd))
+        {
+          stdout:,
+          stderr:,
+          exit_status: status.exitstatus,
+          success: status.success?
+        }
+      end
+    end
+
+    def poll
+      processed = []
+
+      loop do
+        entry = @result_queue.pop(true) # non-blocking
+        processed << entry
+        invoke_callback(entry)
+        remove_job(entry[:job].id)
+      rescue ThreadError
+        break # Queue is empty
+      end
+
+      processed
+    end
+
+    def job(id)
+      @jobs_mutex.synchronize { @active_jobs[id] }
+    end
+
+    def cancel(id)
+      job = job(id)
+      return false unless job
+
+      job.cancel
+    end
+
+    def active_count
+      @jobs_mutex.synchronize { @active_jobs.values.count { |j| !j.finished? } }
+    end
+
+    def busy?
+      active_count.positive?
+    end
+
+    private
+
+    def create_job(&)
+      id = generate_id
+      job = Job.new(id, &)
+      @jobs_mutex.synchronize { @active_jobs[id] = job }
+      job
+    end
+
+    def generate_id
+      @id_mutex.synchronize do
+        @next_id += 1
+      end
+    end
+
+    def remove_job(id)
+      @jobs_mutex.synchronize { @active_jobs.delete(id) }
+    end
+
+    def invoke_callback(entry)
+      entry[:callback]&.call(entry[:job])
+      trigger_autocmd_event(entry[:job])
+    rescue StandardError => e
+      warn "Job callback error: #{e.message}"
+      warn e.backtrace.first(5).join("\n")
+    end
+
+    def trigger_autocmd_event(job)
+      return unless @autocmd
+
+      event = case job.status
+              when Job::Status::COMPLETED then :JobCompleted
+              when Job::Status::FAILED then :JobFailed
+              when Job::Status::CANCELLED then :JobCancelled
+              end
+
+      @autocmd.trigger(event, job:) if event
+    end
+  end
+end

data/lib/mui/key_code.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mui
+  # Key code constants for terminal input handling
+  module KeyCode
+    ESCAPE = 27
+    BACKSPACE = 127
+    ENTER_CR = 13
+    ENTER_LF = 10
+    TAB = 9
+    PRINTABLE_MIN = 32
+    # Extended to support Unicode characters (including CJK)
+    # 0x10FFFF is the maximum valid Unicode code point
+    PRINTABLE_MAX = 0x10FFFF
+
+    # Control key codes (Ctrl+letter)
+    CTRL_SPACE = 0 # Also Ctrl+@ (NUL)
+    CTRL_C = 3
+    CTRL_H = 8   # Also backspace in some terminals
+    CTRL_J = 10  # Also newline
+    CTRL_K = 11
+    CTRL_L = 12
+    CTRL_N = 14
+    CTRL_O = 15
+    CTRL_P = 16
+    CTRL_S = 19
+    CTRL_V = 22
+    CTRL_W = 23
+  end
+end

data/lib/mui/key_handler/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "../error"
+
+module Mui
+  module KeyHandler
+    class MethodNotOverriddenError < Mui::Error; end
+
+    # Base class for mode-specific key handlers
+    class Base
+      attr_accessor :mode_manager
+
+      def initialize(mode_manager, buffer)
+        @mode_manager = mode_manager
+        @buffer = buffer
+      end
+
+      def window
+        @mode_manager&.active_window
+      end
+
+      def buffer
+        window&.buffer || @buffer
+      end
+
+      def editor
+        @mode_manager&.editor
+      end
+
+      # Handle a key input
+      def handle(_key)
+        raise MethodNotOverriddenError, "Subclasses must orverride #handle"
+      end
+
+      private
+
+      def cursor_row
+        window.cursor_row
+      end
+
+      def cursor_col
+        window.cursor_col
+      end
+
+      def cursor_row=(value)
+        window.cursor_row = value
+      end
+
+      def cursor_col=(value)
+        window.cursor_col = value
+      end
+
+      def current_line
+        buffer.line(cursor_row)
+      end
+
+      def current_line_length
+        current_line.length
+      end
+
+      def extract_printable_char(key)
+        if key.is_a?(String)
+          # Curses returns multibyte characters as String
+          key
+        elsif key.is_a?(Integer) && key >= KeyCode::PRINTABLE_MIN && key <= KeyCode::PRINTABLE_MAX
+          # Use UTF-8 encoding to support Unicode characters
+          key.chr(Encoding::UTF_8)
+        end
+      rescue RangeError
+        # Invalid Unicode code point
+        nil
+      end
+
+      def key_to_char(key)
+        key.is_a?(String) ? key : key.chr
+      rescue RangeError
+        nil
+      end
+
+      def execute_pending_motion(char)
+        case @pending_motion
+        when :g
+          char == "g" ? Motion.file_start(buffer, cursor_row, cursor_col) : nil
+        when :f
+          Motion.find_char_forward(buffer, cursor_row, cursor_col, char)
+        when :F
+          Motion.find_char_backward(buffer, cursor_row, cursor_col, char)
+        when :t
+          Motion.till_char_forward(buffer, cursor_row, cursor_col, char)
+        when :T
+          Motion.till_char_backward(buffer, cursor_row, cursor_col, char)
+        end
+      end
+
+      def result(mode: nil, message: nil, quit: false)
+        HandlerResult::Base.new(mode:, message:, quit:)
+      end
+    end
+  end
+end