mui 0.2.0 → 0.4.0

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for TypeScript source code
+      # Extends JavaScript with additional TypeScript-specific patterns
+      class TypeScriptLexer < LexerBase
+        # TypeScript keywords (JavaScript keywords + TypeScript-specific)
+        KEYWORDS = %w[
+          async await break case catch class const continue debugger default
+          delete do else export extends finally for function if import in
+          instanceof let new return static switch throw try typeof var void
+          while with yield
+          abstract as asserts declare enum implements interface keyof
+          module namespace never override private protected public readonly
+          type unknown
+        ].freeze
+
+        # TypeScript constants
+        CONSTANTS = %w[true false null undefined NaN Infinity this super].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/\*.*?\*/}],
+          # Template literal (single line)
+          [:string, /\G`[^`]*`/],
+          # Double quoted string (with escape handling)
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Single quoted string (with escape handling)
+          [:string, /\G'(?:[^'\\]|\\.)*'/],
+          # Regular expression literal
+          [:regex, %r{\G/(?:[^/\\]|\\.)+/[gimsuy]*}],
+          # Float numbers (must be before integer)
+          [:number, /\G\b\d+\.\d+(?:e[+-]?\d+)?\b/i],
+          # Hexadecimal
+          [:number, /\G\b0x[0-9a-fA-F]+n?\b/i],
+          # Octal
+          [:number, /\G\b0o[0-7]+n?\b/i],
+          # Binary
+          [:number, /\G\b0b[01]+n?\b/i],
+          # Integer (with optional BigInt suffix)
+          [:number, /\G\b\d+n?\b/],
+          # Constants (true, false, null, undefined, NaN, Infinity, this, super)
+          [:constant, /\G\b(?:true|false|null|undefined|NaN|Infinity|this|super)\b/],
+          # TypeScript + JavaScript keywords
+          [:keyword, /\G\b(?:abstract|as|asserts|async|await|break|case|catch|class|const|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|function|if|implements|import|in|instanceof|interface|keyof|let|module|namespace|never|new|override|private|protected|public|readonly|return|static|switch|throw|try|type|typeof|unknown|var|void|while|with|yield)\b/],
+          # Generic type parameters <T> and type annotations
+          [:type, /\G<[A-Z][a-zA-Z0-9_,\s]*>/],
+          # Class/constructor/type names (start with uppercase)
+          [:constant, /\G\b[A-Z][a-zA-Z0-9_]*\b/],
+          # Regular identifiers
+          [:identifier, /\G\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/],
+          # Operators (=> must come before = patterns)
+          [:operator, %r{\G(?:\.{3}|=>|&&=?|\|\|=?|\?\?=?|===?|!==?|>>>?=?|<<=?|\+\+|--|\?\.?|[+\-*/%&|^<>=!]=?)}]
+        ].freeze
+
+        # Multiline patterns (pre-compiled)
+        BLOCK_COMMENT_END = %r{\*/}
+        BLOCK_COMMENT_START = %r{/\*}
+        BLOCK_COMMENT_START_ANCHOR = %r{\A/\*}
+
+        # Template literal patterns
+        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
+          COMPILED_PATTERNS
+        end
+
+        # Handle multiline constructs
+        def handle_multiline_state(line, pos, state)
+          case state
+          when :block_comment
+            handle_block_comment(line, pos)
+          when :template_literal
+            handle_template_literal(line, pos)
+          else
+            [nil, nil, pos]
+          end
+        end
+
+        def check_multiline_start(line, pos)
+          rest = line[pos..]
+
+          # Check for template literal start
+          if rest.match?(TEMPLATE_LITERAL_START)
+            after_start = line[(pos + 1)..]
+            unless after_start&.include?("`")
+              text = line[pos..]
+              token = Token.new(
+                type: :string,
+                start_col: pos,
+                end_col: line.length - 1,
+                text:
+              )
+              return [:template_literal, 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_template_literal(line, pos)
+          end_match = line[pos..].match(TEMPLATE_LITERAL_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, :template_literal, line.length]
+          end
+        end
+
+        def match_token(line, pos)
+          # Check for start of template literal
+          if line[pos..].match?(TEMPLATE_LITERAL_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

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

@@ -8,6 +8,7 @@ module Mui
     class Curses < Base
       def init
         ::Curses.init_screen
+        ::Curses.ESCDELAY = 10
         ::Curses.raw
         ::Curses.noecho
         ::Curses.curs_set(1)
@@ -16,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)
@@ -133,18 +151,19 @@ module Mui
       public
 
       def getch_nonblock
-        ::Curses.stdscr.nodelay = true
+        ::Curses.stdscr.timeout = 0
+
         key = ::Curses.getch
-        return key.tap { ::Curses.stdscr.nodelay = false } unless key.is_a?(Integer)
-        return key.tap { ::Curses.stdscr.nodelay = false } if key.negative? || key > 255
-
-        result = if key >= 0x80
-                   read_utf8_char(key)
-                 else
-                   key
-                 end
-        ::Curses.stdscr.nodelay = false
-        result
+
+        return if key == -1 || key.nil?
+        return key unless key.is_a?(Integer)
+        return key if key.negative? || key > 255
+
+        if key >= 0x80
+          read_utf8_char(key)
+        else
+          key
+        end
       end
 
       def suspend
@@ -157,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