mui 0.2.0 → 0.3.0

data/lib/mui/key_sequence_matcher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Mui
+  # Matches input key sequences against registered key mappings
+  class KeySequenceMatcher
+    # Match result types
+    MATCH_EXACT = :exact       # Complete match found
+    MATCH_PARTIAL = :partial   # Input is prefix of one or more registered sequences
+    MATCH_NONE = :none         # No match possible
+
+    # @param keymaps [Hash] Mode => { KeySequence => handler }
+    # @param leader_key [String] The leader key to expand :leader symbols
+    def initialize(keymaps, leader_key)
+      @keymaps = keymaps
+      @leader_key = leader_key
+    end
+
+    # Match input keys against registered keymaps for a mode
+    # @param mode [Symbol] The current mode (:normal, :insert, etc.)
+    # @param input_keys [Array<String>] Array of normalized input keys
+    # @return [Array<Symbol, Object>] [match_type, handler_or_nil]
+    def match(mode, input_keys)
+      mode_keymaps = @keymaps[mode]
+      return [MATCH_NONE, nil] unless mode_keymaps
+      return [MATCH_NONE, nil] if input_keys.empty?
+
+      exact_match = nil
+      has_longer_match = false
+
+      mode_keymaps.each do |sequence, handler|
+        seq_keys = sequence.normalize(@leader_key)
+
+        if seq_keys == input_keys
+          # Exact match found
+          exact_match = handler
+        elsif prefix_match?(input_keys, seq_keys)
+          # Input is a prefix of this sequence (longer sequence exists)
+          has_longer_match = true
+        end
+      end
+
+      if exact_match
+        # Exact match found - return it
+        # If there are also longer matches, caller may want to wait for timeout
+        [MATCH_EXACT, exact_match]
+      elsif has_longer_match
+        # No exact match, but input could lead to a match
+        [MATCH_PARTIAL, nil]
+      else
+        # No match possible
+        [MATCH_NONE, nil]
+      end
+    end
+
+    # Check if there are any longer sequences that could match
+    # Used to determine if we should wait for more input
+    # @param mode [Symbol]
+    # @param input_keys [Array<String>]
+    # @return [Boolean]
+    def longer_sequences?(mode, input_keys)
+      mode_keymaps = @keymaps[mode]
+      return false unless mode_keymaps
+
+      mode_keymaps.any? do |sequence, _handler|
+        seq_keys = sequence.normalize(@leader_key)
+        seq_keys.length > input_keys.length && prefix_match?(input_keys, seq_keys)
+      end
+    end
+
+    private
+
+    # Check if input_keys is a prefix of seq_keys
+    def prefix_match?(input_keys, seq_keys)
+      return false if input_keys.length >= seq_keys.length
+
+      seq_keys.take(input_keys.length) == input_keys
+    end
+  end
+end

data/lib/mui/line_renderer.rb

@@ -17,8 +17,59 @@ module Mui
       render_with_highlights(screen, line, x, y, highlights)
     end
 
+    # Renders a wrapped line segment with screen coordinate-based highlights
+    # wrap_info: { text:, start_col:, end_col: }
+    # options: { selection:, search_state:, logical_row:, visible_width: }
+    def render_wrapped_line(screen, y, x, wrap_info, options = {})
+      text = wrap_info[:text]
+      return if text.nil?
+
+      logical_row = options[:logical_row]
+      start_col = wrap_info[:start_col]
+      end_col = wrap_info[:end_col]
+
+      # Collect highlights for this row and clip to wrapped segment range
+      highlights = collect_highlights(logical_row, text, options)
+      clipped_highlights = clip_highlights_to_range(highlights, start_col, end_col)
+
+      # Adjust highlight positions to be relative to wrap segment start
+      adjusted_highlights = clipped_highlights.map do |h|
+        adjusted_start = h.start_col - start_col
+        adjusted_end = h.end_col - start_col
+        Highlight.new(
+          start_col: adjusted_start,
+          end_col: adjusted_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+
+      render_with_highlights(screen, text, x, y, adjusted_highlights)
+    end
+
     private
 
+    # Clips highlights to a column range and returns only overlapping portions
+    def clip_highlights_to_range(highlights, range_start, range_end)
+      highlights.filter_map do |h|
+        # Skip if highlight doesn't overlap with range
+        next if h.end_col < range_start || h.start_col >= range_end
+
+        # Clip to range
+        clipped_start = [h.start_col, range_start].max
+        clipped_end = [h.end_col, range_end - 1].min
+
+        next if clipped_start > clipped_end
+
+        Highlight.new(
+          start_col: clipped_start,
+          end_col: clipped_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+    end
+
     def collect_highlights(row, line, options)
       @highlighters
         .flat_map { |h| h.highlights_for(row, line, options) }
@@ -36,7 +87,7 @@ module Mui
 
       segments.each do |segment|
         put_text(screen, y, current_x, segment[:text], segment[:style])
-        current_x += segment[:text].length
+        current_x += UnicodeWidth.string_width(segment[:text])
       end
     end
 

data/lib/mui/mode_manager.rb

@@ -4,9 +4,9 @@ module Mui
   # Manages editor mode state and transitions
   class ModeManager
     attr_reader :mode, :selection, :register, :undo_manager, :search_state, :search_input, :editor,
-                :last_visual_selection
+                :last_visual_selection, :key_sequence_handler
 
-    def initialize(window:, buffer:, command_line:, undo_manager: nil, editor: nil, register: nil)
+    def initialize(window:, buffer:, command_line:, undo_manager: nil, editor: nil, register: nil, key_sequence_handler: nil)
       @tab_manager = window.is_a?(TabManager) ? window : nil
       @window_manager = window.is_a?(WindowManager) ? window : nil
       @window = !@tab_manager && !@window_manager ? window : nil
@@ -15,6 +15,7 @@ module Mui
       @register = register || Mui.register
       @undo_manager = undo_manager
       @editor = editor
+      @key_sequence_handler = key_sequence_handler
       @search_state = SearchState.new
       @search_input = SearchInput.new
       @mode = Mode::NORMAL

data/lib/mui/screen.rb

@@ -30,8 +30,8 @@ module Mui
       return if y >= @height || x >= @width
 
       @adapter.setpos(y, x)
-      max_len = @width - x
-      @adapter.addstr(text.length > max_len ? text[0, max_len] : text)
+      max_width = @width - x
+      @adapter.addstr(truncate_to_width(text, max_width))
     end
 
     def put_with_highlight(y, x, text)
@@ -39,9 +39,9 @@ module Mui
       return if y >= @height || x >= @width
 
       @adapter.setpos(y, x)
-      max_len = @width - x
+      max_width = @width - x
       @adapter.with_highlight do
-        @adapter.addstr(text.length > max_len ? text[0, max_len] : text)
+        @adapter.addstr(truncate_to_width(text, max_width))
       end
     end
 
@@ -51,8 +51,8 @@ module Mui
       return put(y, x, text) unless @color_manager && style
 
       @adapter.setpos(y, x)
-      max_len = @width - x
-      truncated_text = text.length > max_len ? text[0, max_len] : text
+      max_width = @width - x
+      truncated_text = truncate_to_width(text, max_width)
 
       pair_index = ensure_color_pair(style[:fg], style[:bg])
       @adapter.with_color(pair_index, bold: style[:bold], underline: style[:underline]) do
@@ -81,5 +81,23 @@ module Mui
       @width = @adapter.width
       @height = @adapter.height
     end
+
+    # Truncates text to fit within max_width display columns
+    def truncate_to_width(text, max_width)
+      return text if max_width <= 0
+
+      current_width = 0
+      result = String.new
+
+      text.each_char do |char|
+        char_w = UnicodeWidth.char_width(char)
+        break if current_width + char_w > max_width
+
+        result << char
+        current_width += char_w
+      end
+
+      result
+    end
   end
 end

data/lib/mui/search_state.rb

@@ -2,81 +2,114 @@
 
 module Mui
   class SearchState
-    attr_reader :pattern, :direction, :matches
+    attr_reader :pattern, :direction
 
     def initialize
       @pattern = nil
       @direction = :forward
-      @matches = []
+      @pattern_version = 0
+      @buffer_matches = {} # { buffer_object_id => { version:, matches: [] } }
     end
 
     def set_pattern(pattern, direction)
       @pattern = pattern
       @direction = direction
-      @matches = []
+      @pattern_version += 1
+      @buffer_matches.clear # Invalidate all cached matches
     end
 
+    # Calculate matches for a specific buffer (used for n/N navigation)
     def find_all_matches(buffer)
-      @matches = []
-      return if @pattern.nil? || @pattern.empty?
+      return [] if @pattern.nil? || @pattern.empty? || buffer.nil?
 
-      begin
-        regex = Regexp.new(@pattern)
-        buffer.line_count.times do |row|
-          line = buffer.line(row)
-          scan_line_matches(line, row, regex)
-        end
-      rescue RegexpError
-        # Invalid regex pattern - no matches
-        @matches = []
-      end
+      get_or_calculate_matches(buffer)
     end
 
-    def find_next(current_row, current_col)
-      return nil if @matches.empty?
+    def find_next(current_row, current_col, buffer: nil)
+      matches = buffer ? get_or_calculate_matches(buffer) : []
+      return nil if matches.empty?
 
       # Find next match after current position
-      match = @matches.find do |m|
+      match = matches.find do |m|
         m[:row] > current_row || (m[:row] == current_row && m[:col] > current_col)
       end
 
       # Wrap around to beginning if no match found
-      match || @matches.first
+      match || matches.first
     end
 
-    def find_previous(current_row, current_col)
-      return nil if @matches.empty?
+    def find_previous(current_row, current_col, buffer: nil)
+      matches = buffer ? get_or_calculate_matches(buffer) : []
+      return nil if matches.empty?
 
       # Find previous match before current position
-      match = @matches.reverse.find do |m|
+      match = matches.reverse.find do |m|
         m[:row] < current_row || (m[:row] == current_row && m[:col] < current_col)
       end
 
       # Wrap around to end if no match found
-      match || @matches.last
+      match || matches.last
     end
 
     def clear
       @pattern = nil
-      @matches = []
+      @pattern_version += 1
+      @buffer_matches.clear
     end
 
     def has_pattern?
       !@pattern.nil? && !@pattern.empty?
     end
 
-    def matches_for_row(row)
-      @matches.select { |m| m[:row] == row }
+    # Get matches for a specific row in a specific buffer
+    def matches_for_row(row, buffer: nil)
+      return [] if buffer.nil?
+
+      matches = get_or_calculate_matches(buffer)
+      matches.select { |m| m[:row] == row }
     end
 
     private
 
-    def scan_line_matches(line, row, regex)
+    def get_or_calculate_matches(buffer)
+      buffer_id = buffer.object_id
+      cached = @buffer_matches[buffer_id]
+
+      # Return cached matches if valid (same pattern version and buffer hasn't changed)
+      return cached[:matches] if cached && cached[:version] == @pattern_version && cached[:change_count] == buffer.change_count
+
+      # Calculate and cache matches for this buffer
+      matches = calculate_matches(buffer)
+      @buffer_matches[buffer_id] = {
+        version: @pattern_version,
+        change_count: buffer.change_count,
+        matches:
+      }
+      matches
+    end
+
+    def calculate_matches(buffer)
+      return [] if @pattern.nil? || @pattern.empty?
+
+      matches = []
+      begin
+        regex = Regexp.new(@pattern)
+        buffer.line_count.times do |row|
+          line = buffer.line(row)
+          scan_line_matches(matches, line, row, regex)
+        end
+      rescue RegexpError
+        # Invalid regex pattern - no matches
+      end
+      matches
+    end
+
+    def scan_line_matches(matches, line, row, regex)
       offset = 0
       while (match_data = line.match(regex, offset))
         col = match_data.begin(0)
         end_col = match_data.end(0) - 1
-        @matches << { row:, col:, end_col: }
+        matches << { row:, col:, end_col: }
         # Move offset past the end of the match to avoid overlapping matches
         offset = match_data.end(0)
         # Handle zero-length matches to prevent infinite loop

data/lib/mui/syntax/language_detector.rb

@@ -12,7 +12,25 @@ module Mui
         ".gemspec" => :ruby,
         ".c" => :c,
         ".h" => :c,
-        ".y" => :c
+        ".y" => :c,
+        ".go" => :go,
+        ".rs" => :rust,
+        ".js" => :javascript,
+        ".mjs" => :javascript,
+        ".cjs" => :javascript,
+        ".jsx" => :javascript,
+        ".ts" => :typescript,
+        ".tsx" => :typescript,
+        ".mts" => :typescript,
+        ".cts" => :typescript,
+        ".md" => :markdown,
+        ".markdown" => :markdown,
+        ".html" => :html,
+        ".htm" => :html,
+        ".xhtml" => :html,
+        ".css" => :css,
+        ".scss" => :css,
+        ".sass" => :css
       }.freeze
 
       # Map basenames (files without extension) to language symbols
@@ -50,6 +68,20 @@ module Mui
             Lexers::RubyLexer.new
           when :c
             Lexers::CLexer.new
+          when :go
+            Lexers::GoLexer.new
+          when :rust
+            Lexers::RustLexer.new
+          when :javascript
+            Lexers::JavaScriptLexer.new
+          when :typescript
+            Lexers::TypeScriptLexer.new
+          when :markdown
+            Lexers::MarkdownLexer.new
+          when :html
+            Lexers::HtmlLexer.new
+          when :css
+            Lexers::CssLexer.new
           end
         end
 

data/lib/mui/syntax/lexers/css_lexer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for CSS source files
+      class CssLexer < LexerBase
+        # Pre-compiled patterns with \G anchor for position-specific matching
+        COMPILED_PATTERNS = [
+          # Single-line block comment /* ... */ on one line
+          [:comment, %r{\G/\*.*?\*/}],
+          # @rules (at-rules)
+          [:preprocessor, /\G@[a-zA-Z-]+/],
+          # Hex color (must be before ID selector - matches 3-8 hex digits only)
+          [:number, /\G#[0-9a-fA-F]{3,8}(?![a-zA-Z0-9_-])/],
+          # ID selector (starts with letter or underscore/hyphen after #)
+          [:constant, /\G#[a-zA-Z_-][a-zA-Z0-9_-]*/],
+          # Class selector
+          [:type, /\G\.[a-zA-Z_-][a-zA-Z0-9_-]*/],
+          # Pseudo-elements and pseudo-classes
+          [:keyword, /\G::?[a-zA-Z-]+(?:\([^)]*\))?/],
+          # Property name (followed by colon)
+          [:identifier, /\G[a-zA-Z-]+(?=\s*:)/],
+          # Double quoted string
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Single quoted string
+          [:string, /\G'(?:[^'\\]|\\.)*'/],
+          # URL function
+          [:string, /\Gurl\([^)]*\)/i],
+          # Numbers with units
+          [:number, /\G-?\d+\.?\d*(?:px|em|rem|%|vh|vw|vmin|vmax|ch|ex|cm|mm|in|pt|pc|deg|rad|grad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx|fr)?/i],
+          # Functions (calc, rgb, rgba, hsl, var, etc.)
+          [:keyword, /\G[a-zA-Z-]+(?=\()/],
+          # Property values / keywords (important, inherit, etc.)
+          [:constant, /\G!important\b/i],
+          [:constant, /\G\b(?:inherit|initial|unset|revert|none|auto|normal)\b/],
+          # Element selectors and identifiers
+          [:identifier, /\G[a-zA-Z_-][a-zA-Z0-9_-]*/],
+          # Operators and symbols
+          [:operator, /\G[{}():;,>+~*=\[\]]/]
+        ].freeze
+
+        # Multiline comment patterns
+        BLOCK_COMMENT_END = %r{\*/}
+        BLOCK_COMMENT_START = %r{/\*}
+        BLOCK_COMMENT_START_ANCHOR = %r{\A/\*}
+
+        protected
+
+        def compiled_patterns
+          COMPILED_PATTERNS
+        end
+
+        # Handle /* ... */ block comments that span multiple lines
+        def handle_multiline_state(line, pos, state)
+          return [nil, nil, pos] unless state == :block_comment
+
+          end_match = line[pos..].match(BLOCK_COMMENT_END)
+          if end_match
+            end_pos = pos + end_match.begin(0) + 1
+            text = line[pos..end_pos]
+            token = Token.new(
+              type: :comment,
+              start_col: pos,
+              end_col: end_pos,
+              text:
+            )
+            [token, nil, end_pos + 1]
+          else
+            text = line[pos..]
+            token = if text.empty?
+                      nil
+                    else
+                      Token.new(
+                        type: :comment,
+                        start_col: pos,
+                        end_col: line.length - 1,
+                        text:
+                      )
+                    end
+            [token, :block_comment, line.length]
+          end
+        end
+
+        def check_multiline_start(line, pos)
+          rest = line[pos..]
+
+          start_match = rest.match(BLOCK_COMMENT_START)
+          return [nil, nil, pos] unless start_match
+
+          start_pos = pos + start_match.begin(0)
+          after_start = line[(start_pos + 2)..]
+
+          if after_start&.include?("*/")
+            [nil, nil, pos]
+          else
+            text = line[start_pos..]
+            token = Token.new(
+              type: :comment,
+              start_col: start_pos,
+              end_col: line.length - 1,
+              text:
+            )
+            [:block_comment, token, line.length]
+          end
+        end
+
+        private
+
+        def match_token(line, pos)
+          if line[pos..].match?(BLOCK_COMMENT_START_ANCHOR)
+            rest = line[(pos + 2)..]
+            return nil unless rest&.include?("*/")
+          end
+
+          super
+        end
+      end
+    end
+  end
+end