mui 0.2.0 → 0.4.0

data/lib/mui/screen.rb

@@ -25,13 +25,19 @@ module Mui
       @adapter.clear
     end
 
+    # Force a complete redraw of the screen
+    # This is needed when multibyte characters may have been corrupted
+    def touchwin
+      @adapter.touchwin
+    end
+
     def put(y, x, text)
       return if y.negative?
       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 +45,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 +57,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 +87,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,87 +2,134 @@
 
 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
+    # O(1) lookup using row_index
+    def matches_for_row(row, buffer: nil)
+      return [] if buffer.nil?
+
+      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 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, row_index = calculate_matches(buffer)
+      @buffer_matches[buffer_id] = {
+        version: @pattern_version,
+        change_count: buffer.change_count,
+        matches:,
+        row_index:
+      }
+      @buffer_matches[buffer_id]
+    end
+
+    def calculate_matches(buffer)
+      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)
+          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, row_index]
+    end
+
     def scan_line_matches(line, row, regex)
+      matches = []
       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
         offset += 1 if match_data[0].empty?
         break if offset >= line.length
       end
+      matches
     end
   end
 end

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/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/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

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

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for Go source code
+      class GoLexer < LexerBase
+        # Go keywords
+        KEYWORDS = %w[
+          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
+        ].freeze
+
+        # Go built-in types
+        TYPES = %w[
+          bool byte complex64 complex128 error float32 float64
+          int int8 int16 int32 int64 rune string
+          uint uint8 uint16 uint32 uint64 uintptr
+          any comparable
+        ].freeze
+
+        # Go constants
+        CONSTANTS = %w[true false nil iota].freeze
+
+        # Pre-compiled patterns with \G anchor for position-specific matching
+        COMPILED_PATTERNS = [
+          # Single line comment
+          [:comment, %r{\G//.*}],
+          # Single-line block comment /* ... */ on one line
+          [:comment, %r{\G/\*.*?\*/}],
+          # Raw string literal (backtick)
+          [:string, /\G`[^`]*`/],
+          # Double quoted string (with escape handling)
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Character literal (rune)
+          [:char, /\G'(?:[^'\\]|\\.)*'/],
+          # Float numbers (must be before integer)
+          [:number, /\G\b\d+\.\d+(?:e[+-]?\d+)?\b/i],
+          # Hexadecimal
+          [:number, /\G\b0x[0-9a-fA-F]+\b/i],
+          # Octal
+          [:number, /\G\b0o[0-7]+\b/i],
+          # Binary
+          [:number, /\G\b0b[01]+\b/i],
+          # Integer
+          [:number, /\G\b\d+\b/],
+          # Constants (true, false, nil, iota)
+          [:constant, /\G\b(?:true|false|nil|iota)\b/],
+          # Types
+          [: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
+          [:identifier, /\G\b[a-z_][a-zA-Z0-9_]*\b/],
+          # Operators
+          [:operator, %r{\G(?:&&|\|\||<-|<<=?|>>=?|&\^=?|[+\-*/%&|^<>=!]=?|:=|\+\+|--)}]
+        ].freeze
+
+        # Multiline comment patterns (pre-compiled)
+        BLOCK_COMMENT_END = %r{\*/}
+        BLOCK_COMMENT_START = %r{/\*}
+        BLOCK_COMMENT_START_ANCHOR = %r{\A/\*}
+
+        # Raw string patterns (pre-compiled)
+        RAW_STRING_START = /\A`/
+        RAW_STRING_END = /`/
+
+        protected
+
+        def compiled_patterns
+          COMPILED_PATTERNS
+        end
+
+        # Handle /* ... */ block comments and raw strings that span multiple lines
+        def handle_multiline_state(line, pos, state)
+          case state
+          when :block_comment
+            handle_block_comment(line, pos)
+          when :raw_string
+            handle_raw_string(line, pos)
+          else
+            [nil, nil, pos]
+          end
+        end
+
+        def check_multiline_start(line, pos)
+          rest = line[pos..]
+
+          # Check for raw string start
+          if rest.match?(RAW_STRING_START)
+            after_start = line[(pos + 1)..]
+            unless after_start&.include?("`")
+              # No closing on this line, enter raw string state
+              text = line[pos..]
+              token = Token.new(
+                type: :string,
+                start_col: pos,
+                end_col: line.length - 1,
+                text:
+              )
+              return [:raw_string, token, line.length]
+            end
+          end
+
+          # Check for /* that doesn't have a matching */ on this line
+          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 handle_block_comment(line, pos)
+          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 handle_raw_string(line, pos)
+          end_match = line[pos..].match(RAW_STRING_END)
+          if end_match
+            end_pos = pos + end_match.begin(0)
+            text = line[pos..end_pos]
+            token = Token.new(
+              type: :string,
+              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: :string,
+                        start_col: pos,
+                        end_col: line.length - 1,
+                        text:
+                      )
+                    end
+            [token, :raw_string, line.length]
+          end
+        end
+
+        def match_token(line, pos)
+          # Check for start of raw string
+          if line[pos..].match?(RAW_STRING_START)
+            rest = line[(pos + 1)..]
+            return nil unless rest&.include?("`")
+          end
+
+          # Check for start of multiline comment
+          if line[pos..].match?(BLOCK_COMMENT_START_ANCHOR)
+            rest = line[(pos + 2)..]
+            return nil unless rest&.include?("*/")
+          end
+
+          super
+        end
+      end
+    end
+  end
+end