mui 0.3.0 → 0.4.1

data/lib/mui/search_state.rb

@@ -62,49 +62,62 @@ module Mui
     end
 
     # Get matches for a specific row in a specific buffer
+    # O(1) lookup using row_index
     def matches_for_row(row, buffer: nil)
       return [] if buffer.nil?
 
-      matches = get_or_calculate_matches(buffer)
-      matches.select { |m| m[:row] == row }
+      cache = get_or_calculate_cache(buffer)
+      cache[:row_index][row] || []
     end
 
     private
 
     def get_or_calculate_matches(buffer)
+      get_or_calculate_cache(buffer)[:matches]
+    end
+
+    def get_or_calculate_cache(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
+      # Return cached data if valid (same pattern version and buffer hasn't changed)
+      return cached if cached && cached[:version] == @pattern_version && cached[:change_count] == buffer.change_count
 
       # Calculate and cache matches for this buffer
-      matches = calculate_matches(buffer)
+      matches, row_index = calculate_matches(buffer)
       @buffer_matches[buffer_id] = {
         version: @pattern_version,
         change_count: buffer.change_count,
-        matches:
+        matches:,
+        row_index:
       }
-      matches
+      @buffer_matches[buffer_id]
     end
 
     def calculate_matches(buffer)
-      return [] if @pattern.nil? || @pattern.empty?
+      empty_result = [[], {}]
+      return empty_result if @pattern.nil? || @pattern.empty?
 
       matches = []
+      row_index = {}
       begin
         regex = Regexp.new(@pattern)
         buffer.line_count.times do |row|
           line = buffer.line(row)
-          scan_line_matches(matches, line, row, regex)
+          row_matches = scan_line_matches(line, row, regex)
+          unless row_matches.empty?
+            matches.concat(row_matches)
+            row_index[row] = row_matches
+          end
         end
       rescue RegexpError
         # Invalid regex pattern - no matches
       end
-      matches
+      [matches, row_index]
     end
 
-    def scan_line_matches(matches, line, row, regex)
+    def scan_line_matches(line, row, regex)
+      matches = []
       offset = 0
       while (match_data = line.match(regex, offset))
         col = match_data.begin(0)
@@ -116,6 +129,7 @@ module Mui
         offset += 1 if match_data[0].empty?
         break if offset >= line.length
       end
+      matches
     end
   end
 end

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

@@ -30,6 +30,8 @@ module Mui
           [:type, /\G\b(?:char|double|float|int|long|short|signed|unsigned|void|_Bool|_Complex|_Imaginary)\b/],
           # Other keywords (if, for, return, const, static, etc.)
           [:keyword, /\G\b(?:auto|break|case|const|continue|default|do|else|enum|extern|for|goto|if|register|return|sizeof|static|struct|switch|typedef|union|volatile|while|inline|restrict|_Alignas|_Alignof|_Atomic|_Generic|_Noreturn|_Static_assert|_Thread_local)\b/],
+          # Function call/definition (identifier followed by parenthesis)
+          [:function_definition, /\G\b[a-zA-Z_][a-zA-Z0-9_]*(?=\s*\()/],
           # Identifiers
           [:identifier, /\G\b[a-zA-Z_][a-zA-Z0-9_]*\b/],
           # Operators

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

@@ -51,6 +51,8 @@ module Mui
           [:type, /\G\b(?:bool|byte|complex64|complex128|error|float32|float64|int|int8|int16|int32|int64|rune|string|uint|uint8|uint16|uint32|uint64|uintptr|any|comparable)\b/],
           # Keywords
           [:keyword, /\G\b(?:break|case|chan|const|continue|default|defer|else|fallthrough|for|func|go|goto|if|import|interface|map|package|range|return|select|struct|switch|type|var)\b/],
+          # Function definition names (func の後)
+          [:function_definition, /\G(?<=func )[a-z_][a-zA-Z0-9_]*/],
           # Exported identifiers (start with uppercase)
           [:constant, /\G\b[A-Z][a-zA-Z0-9_]*\b/],
           # Regular identifiers

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

@@ -61,6 +61,28 @@ module Mui
         TEMPLATE_LITERAL_START = /\A`/
         TEMPLATE_LITERAL_END = /`/
 
+        # Override tokenize to post-process function definitions
+        def tokenize(line, state = nil)
+          tokens, new_state = super
+
+          # Convert identifiers after 'function' keyword to function_definition
+          tokens.each_with_index do |token, i|
+            next unless i.positive? &&
+                        tokens[i - 1].type == :keyword &&
+                        tokens[i - 1].text == "function" &&
+                        token.type == :identifier
+
+            tokens[i] = Token.new(
+              type: :function_definition,
+              start_col: token.start_col,
+              end_col: token.end_col,
+              text: token.text
+            )
+          end
+
+          [tokens, new_state]
+        end
+
         protected
 
         def compiled_patterns

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

@@ -47,6 +47,9 @@ module Mui
           [:global_variable, /\G\$[a-zA-Z_][a-zA-Z0-9_]*/],
           # Method calls (.to_i, .each, .map!, .empty?, etc.)
           [:method_call, /\G\.[a-z_][a-zA-Z0-9_]*[?!]?/],
+          # Function/method definition names (def の後)
+          # Note: def self.method_name is handled by method_call pattern (same color)
+          [:function_definition, /\G(?<=def )[a-z_][a-zA-Z0-9_]*[?!=]?/],
           # Identifiers (including method names with ? or !)
           [:identifier, /\G\b[a-z_][a-zA-Z0-9_]*[?!]?/],
           # Operators

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

@@ -59,6 +59,8 @@ module Mui
           [:type, /\G\b(?:bool|char|str|i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize|f32|f64)\b/],
           # Keywords
           [:keyword, /\G\b(?:as|async|await|break|const|continue|crate|dyn|else|enum|extern|false|fn|for|if|impl|in|let|loop|match|mod|move|mut|pub|ref|return|self|Self|static|struct|super|trait|true|type|unsafe|use|where|while)\b/],
+          # Function definition names (fn の後)
+          [:function_definition, /\G(?<=fn )[a-z_][a-zA-Z0-9_]*/],
           # Type names (start with uppercase)
           [:constant, /\G\b[A-Z][a-zA-Z0-9_]*\b/],
           # Regular identifiers

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

@@ -67,6 +67,28 @@ module Mui
         TEMPLATE_LITERAL_START = /\A`/
         TEMPLATE_LITERAL_END = /`/
 
+        # Override tokenize to post-process function definitions
+        def tokenize(line, state = nil)
+          tokens, new_state = super
+
+          # Convert identifiers after 'function' keyword to function_definition
+          tokens.each_with_index do |token, i|
+            next unless i.positive? &&
+                        tokens[i - 1].type == :keyword &&
+                        tokens[i - 1].text == "function" &&
+                        token.type == :identifier
+
+            tokens[i] = Token.new(
+              type: :function_definition,
+              start_col: token.start_col,
+              end_col: token.end_col,
+              text: token.text
+            )
+          end
+
+          [tokens, new_state]
+        end
+
         protected
 
         def compiled_patterns

data/lib/mui/terminal_adapter/base.rb

@@ -87,6 +87,27 @@ module Mui
       def resume
         raise MethodNotOverriddenError, __method__
       end
+
+      # Check if terminal supports colors
+      def has_colors?
+        raise MethodNotOverriddenError, __method__
+      end
+
+      # Get available color count (8, 256, etc.)
+      def colors
+        raise MethodNotOverriddenError, __method__
+      end
+
+      # Get available color pair count
+      def color_pairs
+        raise MethodNotOverriddenError, __method__
+      end
+
+      # Force a complete redraw of the screen
+      # This is needed when multibyte characters may have been corrupted
+      def touchwin
+        # Default implementation does nothing (for mock adapters)
+      end
     end
   end
 end

data/lib/mui/terminal_adapter/curses.rb

@@ -17,8 +17,25 @@ module Mui
       end
 
       def init_colors
+        return unless ::Curses.has_colors?
+
         ::Curses.start_color
         ::Curses.use_default_colors
+        @has_colors = true
+        @available_colors = ::Curses.respond_to?(:colors) ? ::Curses.colors : 8
+        @max_pairs = ::Curses.respond_to?(:color_pairs) ? ::Curses.color_pairs : 64
+      end
+
+      def has_colors?
+        @has_colors || false
+      end
+
+      def colors
+        @available_colors || 0
+      end
+
+      def color_pairs
+        @max_pairs || 0
       end
 
       def init_color_pair(pair_index, fg, bg)
@@ -159,6 +176,13 @@ module Mui
         ::Curses.refresh
         ::Curses.curs_set(1)
       end
+
+      # Force a complete redraw of the screen
+      # This is needed when multibyte characters may have been corrupted
+      def touchwin
+        ::Curses.stdscr.redraw
+        ::Curses.refresh
+      end
     end
   end
 end