mui 0.1.0 → 0.3.0

data/lib/mui/handler_result.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Mui
+  module HandlerResult
+    # Base class for handler results with common attributes and default implementations
+    class Base
+      attr_reader :mode, :message
+
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false)
+        @mode = mode
+        @message = message
+        @quit = quit
+        @pending_sequence = pending_sequence
+        freeze
+      end
+
+      def quit?
+        @quit
+      end
+
+      # True when waiting for more keys in a multi-key sequence
+      def pending_sequence?
+        @pending_sequence
+      end
+
+      def start_selection?
+        false
+      end
+
+      def line_mode?
+        false
+      end
+
+      def clear_selection?
+        false
+      end
+
+      def toggle_line_mode?
+        false
+      end
+    end
+
+    # Result for NormalMode - handles visual mode start
+    class NormalModeResult < Base
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, start_selection: false, line_mode: false, group_started: false)
+        @start_selection = start_selection
+        @line_mode = line_mode
+        @group_started = group_started
+        super(mode:, message:, quit:, pending_sequence:)
+      end
+
+      def start_selection?
+        @start_selection
+      end
+
+      def line_mode?
+        @line_mode
+      end
+
+      def group_started?
+        @group_started
+      end
+    end
+
+    # Result for VisualMode - handles selection clear and line mode toggle
+    class VisualModeResult < Base
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, clear_selection: false, toggle_line_mode: false, group_started: false)
+        @clear_selection = clear_selection
+        @toggle_line_mode = toggle_line_mode
+        @group_started = group_started
+        super(mode:, message:, quit:, pending_sequence:)
+      end
+
+      def clear_selection?
+        @clear_selection
+      end
+
+      def toggle_line_mode?
+        @toggle_line_mode
+      end
+
+      def group_started?
+        @group_started
+      end
+    end
+
+    # Result for InsertMode - uses base functionality only
+    class InsertModeResult < Base
+    end
+
+    # Result for CommandMode - uses base functionality only
+    class CommandModeResult < Base
+    end
+
+    # Result for SearchMode - handles search execution
+    class SearchModeResult < Base
+      def initialize(mode: nil, message: nil, quit: false, pending_sequence: false, cancelled: false)
+        @cancelled = cancelled
+        super(mode:, message:, quit:, pending_sequence:)
+      end
+
+      def cancelled?
+        @cancelled
+      end
+    end
+  end
+end

data/lib/mui/highlight.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Mui
+  class Highlight
+    attr_reader :start_col, :end_col, :style, :priority
+
+    def initialize(start_col:, end_col:, style:, priority:)
+      @start_col = start_col
+      @end_col = end_col
+      @style = style
+      @priority = priority
+    end
+
+    def overlaps?(other)
+      start_col <= other.end_col && end_col >= other.start_col
+    end
+
+    def <=>(other)
+      [start_col, -priority] <=> [other.start_col, -other.priority]
+    end
+  end
+end

data/lib/mui/highlighters/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mui
+  module Highlighters
+    class Base
+      PRIORITY_SYNTAX = 100
+      PRIORITY_SELECTION = 200
+      PRIORITY_SEARCH = 300
+
+      def initialize(color_scheme)
+        @color_scheme = color_scheme
+      end
+
+      def highlights_for(_row, _line, _options = {})
+        raise Mui::MethodNotOverriddenError, "#{self.class}#highlights_for must be implemented"
+      end
+
+      def priority
+        0
+      end
+    end
+  end
+end

data/lib/mui/highlighters/search_highlighter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mui
+  module Highlighters
+    class SearchHighlighter < Base
+      def highlights_for(row, _line, options = {})
+        search_state = options[:search_state]
+        buffer = options[:buffer]
+        return [] unless search_state&.has_pattern?
+
+        matches = search_state.matches_for_row(row, buffer:)
+        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,107 @@
+# 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,
+        macro: :syntax_keyword,    # Rust macros (println!, vec!, etc.)
+        regex: :syntax_string      # JavaScript/TypeScript regex literals
+      }.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