mui 0.1.0 → 0.2.0

data/lib/mui/syntax/lexer_base.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    # Base class for language-specific lexers
+    # Subclasses should override token_patterns and optionally handle_multiline_state
+    class LexerBase
+      # Tokenize a single line of text
+      # TODO: Refactor to reduce complexity (Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity)
+      def tokenize(line, state = nil)
+        tokens = []
+        pos = 0
+        current_state = state
+
+        while pos < line.length
+          # Handle multiline state first (e.g., inside block comment)
+          if current_state
+            token, new_state, new_pos = handle_multiline_state(line, pos, current_state)
+            if token
+              tokens << token
+              pos = new_pos
+              current_state = new_state
+              next
+            elsif new_state.nil?
+              # State ended, continue normal tokenization
+              current_state = nil
+              pos = new_pos
+              next
+            end
+          end
+
+          # Check for multiline state start
+          new_state, token, new_pos = check_multiline_start(line, pos)
+          if new_state
+            tokens << token if token
+            pos = new_pos
+            current_state = new_state
+            next
+          end
+
+          # Normal token matching
+          token = match_token(line, pos)
+          if token
+            tokens << token
+            pos = token.end_col + 1
+          else
+            # Skip unrecognized character
+            pos += 1
+          end
+        end
+
+        [tokens, current_state]
+      end
+
+      # Check if a state continues to the next line
+      def continuing_state?(state)
+        !state.nil?
+      end
+
+      protected
+
+      # Override in subclass to define token patterns
+      def token_patterns
+        []
+      end
+
+      # Override in subclass to handle multiline constructs
+      def handle_multiline_state(_line, pos, _state)
+        [nil, nil, pos]
+      end
+
+      # Override in subclass to check for multiline construct starts
+      def check_multiline_start(_line, pos)
+        [nil, nil, pos]
+      end
+
+      private
+
+      # Get compiled patterns (cached)
+      # Uses \G anchor for efficient matching at specific position
+      def compiled_patterns
+        @compiled_patterns ||= token_patterns.map do |type, pattern|
+          [type, /\G#{pattern}/]
+        end
+      end
+
+      def match_token(line, pos)
+        return nil if pos >= line.length
+
+        compiled_patterns.each do |type, pattern|
+          match = pattern.match(line, pos)
+          next unless match
+
+          text = match[0]
+          return Token.new(
+            type:,
+            start_col: pos,
+            end_col: pos + text.length - 1,
+            text:
+          )
+        end
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for C source code
+      class CLexer < LexerBase
+        # Pre-compiled patterns with \G anchor for position-specific matching
+        # These are compiled once at class load time
+        COMPILED_PATTERNS = [
+          # Single line comment
+          [:comment, %r{\G//.*}],
+          # Single-line block comment /* ... */ on one line
+          [:comment, %r{\G/\*.*?\*/}],
+          # Double quoted string (with escape handling)
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Character literal
+          [:char, /\G'(?:[^'\\]|\\.)*'/],
+          # Preprocessor directives
+          [:preprocessor, /\G^\s*#\s*(?:include|define|undef|ifdef|ifndef|if|else|elif|endif|error|pragma|line)\b.*/],
+          # Float numbers (must be before integer)
+          [:number, /\G\b\d+\.\d+(?:e[+-]?\d+)?[fFlL]?\b/i],
+          # Hexadecimal
+          [:number, /\G\b0x[0-9a-fA-F]+[uUlL]*\b/],
+          # Octal
+          [:number, /\G\b0[0-7]+[uUlL]*\b/],
+          # Integer
+          [:number, /\G\b\d+[uUlL]*\b/],
+          # Type keywords (int, char, void, etc.)
+          [: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/],
+          # Identifiers
+          [:identifier, /\G\b[a-zA-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
+
+        # Use pre-compiled class-level patterns
+        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
+
+          # Look for */
+          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
+            # Entire line is part of block comment
+            text = line[pos..]
+            unless text.empty?
+              token = Token.new(
+                type: :comment,
+                start_col: pos,
+                end_col: line.length - 1,
+                text:
+              )
+            end
+            [token, :block_comment, line.length]
+          end
+        end
+
+        # Check for /* block comment start (that doesn't end on the same line)
+        def check_multiline_start(line, pos)
+          rest = line[pos..]
+
+          # 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)..]
+
+          # Check if there's a closing */ on the same line after this /*
+          if after_start&.include?("*/")
+            # There's a closing on this line, let normal token matching handle it
+            [nil, nil, pos]
+          else
+            # No closing on this line, enter block comment state
+            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)
+          # First check for start of multiline comment
+          if line[pos..].match?(BLOCK_COMMENT_START_ANCHOR)
+            rest = line[(pos + 2)..]
+            unless rest&.include?("*/")
+              # This will be handled by check_multiline_start
+              return nil
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    module Lexers
+      # Lexer for Ruby source code
+      class RubyLexer < LexerBase
+        KEYWORDS = %w[
+          BEGIN END __ENCODING__ __END__ __FILE__ __LINE__
+          alias and begin break case class def defined? do
+          else elsif end ensure false for if in module next
+          nil not or redo rescue retry return self super then
+          true undef unless until when while yield
+          require require_relative attr_reader attr_writer attr_accessor
+          private protected public include extend prepend
+          raise fail catch throw
+        ].freeze
+
+        # Pre-compiled patterns with \G anchor for position-specific matching
+        # These are compiled once at class load time
+        COMPILED_PATTERNS = [
+          # Single line comment
+          [:comment, /\G#.*/],
+          # Double quoted string (with escape handling)
+          [:string, /\G"(?:[^"\\]|\\.)*"/],
+          # Single quoted string (with escape handling)
+          [:string, /\G'(?:[^'\\]|\\.)*'/],
+          # Symbols
+          [:symbol, /\G:[a-zA-Z_][a-zA-Z0-9_]*[?!]?/],
+          # Float numbers (must be before integer)
+          [:number, /\G\b\d+\.\d+(?:e[+-]?\d+)?\b/i],
+          # Hexadecimal
+          [:number, /\G\b0x[0-9a-f]+\b/i],
+          # Octal
+          [:number, /\G\b0o?[0-7]+\b/],
+          # Binary
+          [:number, /\G\b0b[01]+\b/i],
+          # Integer
+          [:number, /\G\b\d+\b/],
+          # Constants (capitalized identifiers)
+          [:constant, /\G\b[A-Z][a-zA-Z0-9_]*\b/],
+          # Keywords
+          [:keyword, /\G\b(?:BEGIN|END|__ENCODING__|__END__|__FILE__|__LINE__|alias|and|begin|break|case|class|def|defined\?|do|else|elsif|end|ensure|false|for|if|in|module|next|nil|not|or|redo|rescue|retry|return|self|super|then|true|undef|unless|until|when|while|yield|require|require_relative|attr_reader|attr_writer|attr_accessor|private|protected|public|include|extend|prepend|raise|fail|catch|throw)\b/],
+          # Instance variables (@foo, @@foo)
+          [:instance_variable, /\G@{1,2}[a-zA-Z_][a-zA-Z0-9_]*/],
+          # Global variables
+          [: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_]*[?!]?/],
+          # Identifiers (including method names with ? or !)
+          [:identifier, /\G\b[a-z_][a-zA-Z0-9_]*[?!]?/],
+          # Operators
+          [:operator, %r{\G(?:[+\-*/%&|^~<>=!]+|<<|>>|\*\*)}]
+        ].freeze
+
+        # Multiline patterns (also pre-compiled)
+        BLOCK_COMMENT_END = /\A=end\b/
+        BLOCK_COMMENT_START = /\A=begin\b/
+
+        protected
+
+        # Use pre-compiled class-level patterns
+        def compiled_patterns
+          COMPILED_PATTERNS
+        end
+
+        # Handle =begin...=end block comments
+        def handle_multiline_state(line, pos, state)
+          return [nil, nil, pos] unless state == :block_comment
+
+          # Check for =end
+          text = line[pos..]
+          if BLOCK_COMMENT_END.match?(text)
+            token = Token.new(
+              type: :comment,
+              start_col: pos,
+              end_col: line.length - 1,
+              text:
+            )
+            [token, nil, line.length]
+          else
+            # Entire line is part of block comment
+            unless text.empty?
+              token = Token.new(
+                type: :comment,
+                start_col: pos,
+                end_col: line.length - 1,
+                text:
+              )
+            end
+            [token, :block_comment, line.length]
+          end
+        end
+
+        # Check for =begin block comment start
+        def check_multiline_start(line, pos)
+          return [nil, nil, pos] unless pos.zero?
+
+          if BLOCK_COMMENT_START.match?(line)
+            token = Token.new(
+              type: :comment,
+              start_col: 0,
+              end_col: line.length - 1,
+              text: line
+            )
+            [:block_comment, token, line.length]
+          else
+            [nil, nil, pos]
+          end
+        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