mui 0.1.0 → 0.3.0

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for Rust source code
+      class RustLexer < LexerBase
+        # Rust keywords
+        KEYWORDS = %w[
+          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
+        ].freeze
+
+        # Rust primitive types
+        TYPES = %w[
+          bool char str
+          i8 i16 i32 i64 i128 isize
+          u8 u16 u32 u64 u128 usize
+          f32 f64
+        ].freeze
+
+        # Pre-compiled patterns with \G anchor for position-specific matching
+        COMPILED_PATTERNS = [
+          # Doc comments (must be before regular comments)
+          [:comment, %r{\G///.*}],
+          [:comment, %r{\G//!.*}],
+          # Single line comment
+          [:comment, %r{\G//.*}],
+          # Single-line block comment /* ... */ on one line
+          [:comment, %r{\G/\*.*?\*/}],
+          # Attributes
+          [:preprocessor, /\G#!\[[^\]]*\]/],
+          [:preprocessor, /\G#\[[^\]]*\]/],
+          # Character literal - single char or escape sequence (must be before lifetime)
+          [:char, /\G'(?:[^'\\]|\\.)'/],
+          # Lifetime
+          [:symbol, /\G'[a-z_][a-zA-Z0-9_]*/],
+          # Raw string r#"..."#
+          [:string, /\Gr#+"[^"]*"#+/],
+          # Byte string
+          [:string, /\Gb"(?:[^"\\]|\\.)*"/],
+          # Regular string
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Float numbers (must be before integer)
+          [:number, /\G\b\d+\.\d+(?:e[+-]?\d+)?(?:f32|f64)?\b/i],
+          # Hexadecimal
+          [:number, /\G\b0x[0-9a-fA-F_]+(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)?\b/],
+          # Octal
+          [:number, /\G\b0o[0-7_]+(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)?\b/],
+          # Binary
+          [:number, /\G\b0b[01_]+(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)?\b/],
+          # Integer
+          [:number, /\G\b\d[0-9_]*(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize)?\b/],
+          # Macros (identifier followed by !)
+          [:macro, /\G\b[a-z_][a-zA-Z0-9_]*!/],
+          # Primitive types
+          [: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/],
+          # Type names (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/\*}
+
+        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/typescript_lexer.rb

@@ -0,0 +1,203 @@
+# 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 = /`/
+
+        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/syntax/token.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    # Represents a token identified by a lexer
+    # Tokens are immutable value objects
+    class Token
+      attr_reader :type, :start_col, :end_col, :text
+
+      # Token types:
+      # :keyword     - language keywords (def, class, if, etc.)
+      # :string      - string literals ("...", '...')
+      # :comment     - comments (#..., //..., /* ... */)
+      # :number      - numeric literals (123, 1.5, 0xFF)
+      # :symbol      - Ruby symbols (:symbol)
+      # :constant    - constants (ClassName, CONST)
+      # :operator    - operators (+, -, =, etc.)
+      # :identifier  - variable names, method names
+      # :preprocessor - C preprocessor directives (#include, #define)
+      # :char        - character literals ('a')
+      def initialize(type:, start_col:, end_col:, text:)
+        @type = type
+        @start_col = start_col
+        @end_col = end_col
+        @text = text
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Token)
+
+        type == other.type &&
+          start_col == other.start_col &&
+          end_col == other.end_col &&
+          text == other.text
+      end
+
+      def length
+        text.length
+      end
+    end
+  end
+end

data/lib/mui/syntax/token_cache.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    # Caches tokenization results on a per-line basis
+    # Handles multiline state propagation across lines
+    class TokenCache
+      # Number of lines to prefetch ahead/behind visible area
+      PREFETCH_LINES = 50
+
+      def initialize(lexer)
+        @lexer = lexer
+        @cache = {} # row => { tokens:, line_hash:, state_after: }
+      end
+
+      # Get tokens for a specific line, using cache when available
+      # Only tokenizes the requested line - does NOT pre-compute previous lines
+      def tokens_for(row, line, _buffer_lines)
+        line_hash = line.hash
+
+        # Check cache validity (single hash lookup)
+        cached = @cache[row]
+        return cached[:tokens] if cached && cached[:line_hash] == line_hash
+
+        # Get state from previous line's cache (if available)
+        # If not available, assume nil (no multiline state)
+        # This trades accuracy for performance - multiline constructs
+        # may not highlight correctly until user scrolls through the file
+        prev_cached = @cache[row - 1]
+        state_before = prev_cached&.dig(:state_after)
+
+        # Tokenize this line
+        tokens, state_after = @lexer.tokenize(line, state_before)
+
+        # Store in cache
+        @cache[row] = {
+          tokens:,
+          line_hash:,
+          state_after:
+        }
+
+        tokens
+      end
+
+      # Prefetch tokens for lines around the visible area
+      def prefetch(visible_start, visible_end, buffer_lines)
+        return if buffer_lines.empty?
+
+        # Calculate prefetch range
+        prefetch_start = [visible_start - PREFETCH_LINES, 0].max
+        prefetch_end = [visible_end + PREFETCH_LINES, buffer_lines.length - 1].min
+
+        # Tokenize lines that aren't cached yet
+        (prefetch_start..prefetch_end).each do |row|
+          line = buffer_lines[row]
+          next if line.nil?
+
+          line_hash = line.hash
+          cached = @cache[row]
+          next if cached && cached[:line_hash] == line_hash
+
+          prev_cached = @cache[row - 1]
+          state_before = prev_cached&.dig(:state_after)
+          tokens, state_after = @lexer.tokenize(line, state_before)
+
+          @cache[row] = {
+            tokens:,
+            line_hash:,
+            state_after:
+          }
+        end
+      end
+
+      # Invalidate cache from a specific row onwards
+      # This is called when a line is modified
+      def invalidate(from_row)
+        @cache.delete_if { |row, _| row >= from_row }
+      end
+
+      # Clear the entire cache
+      def clear
+        @cache.clear
+      end
+
+      # Check if a row has cached data
+      def cached?(row)
+        @cache.key?(row)
+      end
+    end
+  end
+end

data/lib/mui/tab_bar_renderer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Mui
+  # Renders the tab bar at the top of the screen
+  class TabBarRenderer
+    TAB_BAR_HEIGHT = 1
+    SEPARATOR_HEIGHT = 1
+    TAB_SEPARATOR = " | "
+    SEPARATOR_CHAR = "─"
+
+    def initialize(tab_manager, color_scheme: nil)
+      @tab_manager = tab_manager
+      @color_scheme = color_scheme
+    end
+
+    def render(screen, row = 0)
+      return unless should_render?
+
+      render_tabs(screen, row)
+      render_separator_line(screen, row + TAB_BAR_HEIGHT)
+    end
+
+    def height
+      should_render? ? TAB_BAR_HEIGHT + SEPARATOR_HEIGHT : 0
+    end
+
+    private
+
+    def should_render?
+      @tab_manager.tab_count > 1
+    end
+
+    def render_tabs(screen, row)
+      col = 0
+
+      @tab_manager.tabs.each_with_index do |tab, i|
+        # Add separator between tabs
+        if i.positive?
+          screen.put_with_style(row, col, TAB_SEPARATOR, tab_bar_style)
+          col += TAB_SEPARATOR.length
+        end
+
+        # Render tab with appropriate style
+        tab_text = build_tab_text(tab, i)
+        style = i == @tab_manager.current_index ? tab_bar_active_style : tab_bar_style
+        screen.put_with_style(row, col, tab_text, style)
+        col += tab_text.length
+      end
+
+      # Fill remaining space with tab bar style
+      remaining = screen.width - col
+      screen.put_with_style(row, col, " " * remaining, tab_bar_style) if remaining.positive?
+    end
+
+    def render_separator_line(screen, row)
+      separator_line = SEPARATOR_CHAR * screen.width
+      screen.put_with_style(row, 0, separator_line, separator_style)
+    end
+
+    def build_tab_text(tab, index)
+      marker = index == @tab_manager.current_index ? "*" : " "
+      "#{marker}#{index + 1}:#{truncate_name(tab.display_name, 15)}"
+    end
+
+    def truncate_name(name, max_length)
+      return name if name.length <= max_length
+
+      "#{name[0, max_length - 1]}~"
+    end
+
+    def tab_bar_style
+      @color_scheme&.[](:tab_bar) || @color_scheme&.[](:status_line) || default_style
+    end
+
+    def tab_bar_active_style
+      @color_scheme&.[](:tab_bar_active) || @color_scheme&.[](:status_line_mode) || default_style
+    end
+
+    def separator_style
+      @color_scheme&.[](:separator) || @color_scheme&.[](:status_line) || default_style
+    end
+
+    def default_style
+      { fg: :white, bg: :blue, bold: false, underline: false }
+    end
+  end
+end

data/lib/mui/tab_manager.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages multiple tab pages
+  # Each tab page has its own window layout
+  class TabManager
+    attr_reader :tabs, :current_index
+
+    def initialize(screen, color_scheme: nil)
+      @screen = screen
+      @color_scheme = color_scheme
+      @tabs = []
+      @current_index = 0
+    end
+
+    def current_tab
+      @tabs[@current_index]
+    end
+
+    def add(tab = nil)
+      tab ||= TabPage.new(@screen, color_scheme: @color_scheme)
+      @tabs << tab
+      @current_index = @tabs.size - 1
+      tab
+    end
+
+    # rubocop:disable Naming/PredicateMethod
+    def close_current
+      return false if single_tab?
+
+      @tabs.delete_at(@current_index)
+      @current_index = [@current_index, @tabs.size - 1].min
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def next_tab
+      return if @tabs.empty?
+
+      @current_index = (@current_index + 1) % @tabs.size
+    end
+
+    def prev_tab
+      return if @tabs.empty?
+
+      @current_index = (@current_index - 1) % @tabs.size
+    end
+
+    def first_tab
+      return if @tabs.empty?
+
+      @current_index = 0
+    end
+
+    def last_tab
+      return if @tabs.empty?
+
+      @current_index = @tabs.size - 1
+    end
+
+    # rubocop:disable Naming/PredicateMethod
+    def go_to(index)
+      return false if index.negative? || index >= @tabs.size
+
+      @current_index = index
+      true
+    end
+
+    def move_tab(position)
+      return false if @tabs.size <= 1
+
+      tab = @tabs.delete_at(@current_index)
+      new_position = position.clamp(0, @tabs.size)
+      @tabs.insert(new_position, tab)
+      @current_index = new_position
+      true
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def tab_count
+      @tabs.size
+    end
+
+    def single_tab?
+      @tabs.size <= 1
+    end
+
+    def window_manager
+      current_tab&.window_manager
+    end
+
+    def active_window
+      current_tab&.active_window
+    end
+  end
+end

data/lib/mui/tab_page.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mui
+  # Represents a single tab page containing a window manager
+  # Each tab page has its own independent window layout
+  class TabPage
+    attr_reader :window_manager
+    attr_accessor :name
+
+    def initialize(screen, color_scheme: nil, name: nil)
+      @window_manager = WindowManager.new(screen, color_scheme:)
+      @name = name
+    end
+
+    def active_window
+      @window_manager.active_window
+    end
+
+    def layout_root
+      @window_manager.layout_root
+    end
+
+    def windows
+      @window_manager.windows
+    end
+
+    def window_count
+      @window_manager.window_count
+    end
+
+    def display_name
+      @name || active_window&.buffer&.name || "[No Name]"
+    end
+  end
+end