mui 0.1.0 → 0.3.0

data/lib/mui/buffer.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+module Mui
+  class Buffer
+    attr_reader :lines, :change_count
+    attr_accessor :name, :modified, :undo_manager, :readonly
+
+    # Alias for autocmd pattern matching
+    alias file_path name
+
+    def initialize(name = "[No Name]")
+      @name = name
+      @lines = [empty_line]
+      @modified = false
+      @undo_manager = nil
+      @readonly = false
+      @custom_highlighter_map = {}
+      @change_count = 0
+    end
+
+    def readonly?
+      @readonly
+    end
+
+    # Override in subclasses to provide buffer-specific highlighters
+    def custom_highlighters(_color_scheme)
+      @custom_highlighter_map.values
+    end
+
+    # Add a custom highlighter with a unique key
+    def add_custom_highlighter(key, highlighter)
+      @custom_highlighter_map[key] = highlighter
+    end
+
+    # Remove a custom highlighter by key
+    def remove_custom_highlighter(key)
+      @custom_highlighter_map.delete(key)
+    end
+
+    # Check if a custom highlighter exists
+    def custom_highlighter?(key)
+      @custom_highlighter_map.key?(key)
+    end
+
+    # Set content directly (for scratch buffers)
+    def content=(text)
+      @lines = text.split("\n", -1)
+      @lines = [empty_line] if @lines.empty?
+      @modified = false
+    end
+
+    # Reload file from disk
+    def reload
+      return unless @name && File.exist?(@name)
+
+      load(@name)
+    end
+
+    def load(path)
+      @name = path
+      if File.exist?(path)
+        @lines = File.readlines(path, chomp: true)
+        @lines = [empty_line] if @lines.empty?
+      end
+      @modified = false
+    end
+
+    def save(path = @name)
+      File.write(path, "#{@lines.join("\n")}\n")
+      @name = path
+      @modified = false
+    end
+
+    def line_count
+      @lines.size
+    end
+
+    def line(n)
+      @lines[n] || ""
+    end
+
+    def insert_char(row, col, char)
+      with_undo(InsertCharAction.new(row, col, char)) do
+        insert_char_without_record(row, col, char)
+      end
+    end
+
+    def delete_char(row, col)
+      return unless valid_char_position?(row, col)
+
+      char = @lines[row][col]
+      with_undo(DeleteCharAction.new(row, col, char)) do
+        delete_char_without_record(row, col)
+      end
+    end
+
+    def insert_line(row, text = nil)
+      actual_text = text&.dup || empty_line
+      with_undo(InsertLineAction.new(row, actual_text)) do
+        insert_line_without_record(row, actual_text)
+      end
+    end
+
+    def delete_line(row)
+      text = @lines[row]&.dup
+      return unless text
+
+      with_undo(DeleteLineAction.new(row, text)) do
+        delete_line_without_record(row)
+      end
+    end
+
+    def split_line(row, col)
+      return unless @lines[row]
+
+      with_undo(SplitLineAction.new(row, col)) do
+        split_line_without_record(row, col)
+      end
+    end
+
+    def join_lines(row)
+      return if row >= line_count - 1
+
+      col = @lines[row]&.size || 0
+      with_undo(JoinLinesAction.new(row, col)) do
+        join_lines_without_record(row)
+      end
+    end
+
+    def delete_range(start_row, start_col, end_row, end_col)
+      deleted_lines = capture_range(start_row, start_col, end_row, end_col)
+      with_undo(DeleteRangeAction.new(start_row, start_col, end_row, end_col, deleted_lines)) do
+        delete_range_without_record(start_row, start_col, end_row, end_col)
+      end
+    end
+
+    def replace_line(row, text)
+      old_text = @lines[row]&.dup || empty_line
+      with_undo(ReplaceLineAction.new(row, old_text, text.dup)) do
+        replace_line_without_record(row, text)
+      end
+    end
+
+    def insert_char_without_record(row, col, char)
+      @lines[row] ||= empty_line
+      @lines[row].insert(col, char)
+      @modified = true
+      @change_count += 1
+    end
+
+    def delete_char_without_record(row, col)
+      return unless valid_char_position?(row, col)
+
+      @lines[row].slice!(col)
+      @modified = true
+      @change_count += 1
+    end
+
+    def insert_line_without_record(row, text = nil)
+      @lines.insert(row, text&.dup || empty_line)
+      @modified = true
+      @change_count += 1
+    end
+
+    def delete_line_without_record(row)
+      @lines.delete_at(row)
+      @lines = [empty_line] if @lines.empty?
+      @modified = true
+      @change_count += 1
+    end
+
+    def split_line_without_record(row, col)
+      return unless @lines[row]
+
+      rest = (@lines[row][col..] || "").dup
+      @lines[row] = (@lines[row][0...col] || "").dup
+      insert_line_without_record(row + 1, rest)
+    end
+
+    def join_lines_without_record(row)
+      return if row >= line_count - 1
+
+      @lines[row] = ((@lines[row] || "") + (@lines[row + 1] || "")).dup
+      delete_line_without_record(row + 1)
+    end
+
+    def delete_range_without_record(start_row, start_col, end_row, end_col)
+      if start_row == end_row
+        delete_within_line(start_row, start_col, end_col)
+      else
+        delete_across_lines(start_row, start_col, end_row, end_col)
+      end
+      @modified = true
+      @change_count += 1
+    end
+
+    def replace_line_without_record(row, text)
+      @lines[row] = text.dup
+      @modified = true
+      @change_count += 1
+    end
+
+    def restore_range(start_row, start_col, deleted_lines)
+      return if deleted_lines.empty?
+
+      current_line = @lines[start_row] || empty_line
+      if deleted_lines.size == 1
+        # Single line restore: insert at start_col
+        @lines[start_row] = current_line[0...start_col] + deleted_lines[0] + current_line[start_col..]
+      else
+        # Multi-line restore
+        first_part = current_line[0...start_col]
+        last_part = current_line[start_col..]
+
+        # Set first line
+        @lines[start_row] = first_part + deleted_lines[0]
+
+        # Insert middle lines
+        (1...(deleted_lines.size - 1)).each do |i|
+          @lines.insert(start_row + i, deleted_lines[i].dup)
+        end
+
+        # Insert last line with remainder
+        last_deleted = deleted_lines[-1]
+        @lines.insert(start_row + deleted_lines.size - 1, last_deleted + last_part)
+      end
+      @modified = true
+      @change_count += 1
+    end
+
+    private
+
+    def with_undo(action)
+      @undo_manager&.record(action)
+      yield
+    end
+
+    def valid_char_position?(row, col)
+      !col.negative? && @lines[row] && col < @lines[row].size
+    end
+
+    def empty_line
+      String.new
+    end
+
+    def capture_range(start_row, start_col, end_row, end_col)
+      if start_row == end_row
+        line = @lines[start_row] || ""
+        [line[start_col..end_col] || ""]
+      else
+        lines = []
+        lines << ((@lines[start_row] || "")[start_col..] || "")
+        ((start_row + 1)...end_row).each do |row|
+          lines << (@lines[row]&.dup || "")
+        end
+        lines << ((@lines[end_row] || "")[0..end_col] || "")
+        lines
+      end
+    end
+
+    def delete_within_line(row, start_col, end_col)
+      line = @lines[row] || ""
+      @lines[row] = (line[0...start_col] || "") + (line[(end_col + 1)..] || "")
+    end
+
+    def delete_across_lines(start_row, start_col, end_row, end_col)
+      first_part = (@lines[start_row] || "")[0...start_col] || ""
+      last_part = (@lines[end_row] || "")[(end_col + 1)..] || ""
+
+      (end_row - start_row).times { @lines.delete_at(start_row + 1) }
+
+      @lines[start_row] = first_part + last_part
+    end
+  end
+end

data/lib/mui/buffer_word_cache.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Mui
+  # Caches words from buffer for fast completion
+  # Built once when entering Insert mode, updated incrementally on changes
+  class BufferWordCache
+    # Minimum word length to include in cache
+    MIN_WORD_LENGTH = 2
+    # Maximum candidates to return (for performance)
+    MAX_CANDIDATES = 50
+
+    def initialize(buffer)
+      @buffer = buffer
+      @words = Set.new
+      @dirty_rows = Set.new
+      build_cache
+    end
+
+    # Get completion candidates matching the prefix
+    def complete(prefix, cursor_row, cursor_col)
+      return [] if prefix.empty?
+
+      # Process any dirty rows first
+      process_dirty_rows(cursor_row, cursor_col)
+
+      # Get word at cursor to exclude it
+      word_at_cursor = word_at_position(cursor_row, cursor_col)
+
+      prefix_downcase = prefix.downcase
+      candidates = @words.select do |w|
+        w != prefix && w != word_at_cursor && w.downcase.start_with?(prefix_downcase)
+      end
+      candidates.to_a.sort.first(MAX_CANDIDATES)
+    end
+
+    # Get the full word at cursor position (for exclusion)
+    def word_at_position(row, col)
+      line = @buffer.line(row)
+      return nil if line.empty?
+
+      # Find word boundaries
+      start_col = col
+      start_col -= 1 while start_col.positive? && word_char?(line[start_col - 1])
+
+      end_col = col
+      end_col += 1 while end_col < line.length && word_char?(line[end_col])
+
+      word = line[start_col...end_col]
+      word && word.length >= MIN_WORD_LENGTH ? word : nil
+    end
+
+    # Mark a row as dirty (needs re-scanning)
+    def mark_dirty(row)
+      @dirty_rows << row
+    end
+
+    # Add a word directly (for incremental updates)
+    def add_word(word)
+      @words << word if word.length >= MIN_WORD_LENGTH
+    end
+
+    # Get the word prefix at cursor position
+    def prefix_at(row, col)
+      line = @buffer.line(row)
+      return "" if col.zero? || line.empty?
+
+      start_col = col
+      start_col -= 1 while start_col.positive? && word_char?(line[start_col - 1])
+
+      line[start_col...col] || ""
+    end
+
+    private
+
+    # Regex to match word characters (alphanumeric + underscore)
+    WORD_REGEX = /\w+/
+
+    def build_cache
+      @buffer.lines.each do |line|
+        extract_words_fast(line)
+      end
+    end
+
+    def process_dirty_rows(exclude_row, exclude_col)
+      return if @dirty_rows.empty?
+
+      @dirty_rows.each do |row|
+        next if row >= @buffer.line_count
+
+        line = @buffer.line(row)
+        extract_words_with_exclusion(line, exclude_row, exclude_col, row)
+      end
+      @dirty_rows.clear
+    end
+
+    # Fast word extraction using scan (for initial cache build)
+    def extract_words_fast(line)
+      line.scan(WORD_REGEX) do |word|
+        @words << word if word.length >= MIN_WORD_LENGTH
+      end
+    end
+
+    # Word extraction with cursor position exclusion (for dirty row processing)
+    def extract_words_with_exclusion(line, exclude_row, exclude_col, current_row)
+      line.scan(WORD_REGEX) do |word|
+        next if word.length < MIN_WORD_LENGTH
+
+        # Get match position
+        match = Regexp.last_match
+        word_start = match.begin(0)
+        word_end = match.end(0)
+
+        # Skip word at cursor position
+        next if exclude_row && current_row == exclude_row && word_start <= exclude_col && word_end > exclude_col
+
+        @words << word
+      end
+    end
+
+    def word_char?(char)
+      # Direct character check is faster than regex for single chars
+      return false unless char
+
+      c = char.ord
+      c.between?(48, 57) || # 0-9
+        c.between?(65, 90) ||  # A-Z
+        c.between?(97, 122) || # a-z
+        c == 95 # _
+    end
+  end
+end

data/lib/mui/buffer_word_completer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Mui
+  # Collects words from buffer for completion
+  class BufferWordCompleter
+    # Minimum word length to include in completion
+    MIN_WORD_LENGTH = 2
+    # Maximum candidates to collect (for performance)
+    MAX_CANDIDATES = 50
+
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    # Get completion candidates matching the prefix
+    # Optimized to filter while collecting, stopping early when enough candidates found
+    def complete(prefix, cursor_row, cursor_col)
+      return [] if prefix.empty?
+
+      candidates = Set.new
+      prefix_downcase = prefix.downcase
+
+      @buffer.lines.each_with_index do |line, row|
+        extract_matching_words(line, row, cursor_row, cursor_col, prefix, prefix_downcase, candidates)
+        break if candidates.size >= MAX_CANDIDATES
+      end
+
+      candidates.to_a.sort
+    end
+
+    # Get the word prefix at cursor position
+    def prefix_at(row, col)
+      line = @buffer.line(row)
+      return "" if col.zero? || line.empty?
+
+      # Find word start
+      start_col = col
+      start_col -= 1 while start_col.positive? && word_char?(line[start_col - 1])
+
+      line[start_col...col] || ""
+    end
+
+    private
+
+    def extract_matching_words(line, row, exclude_row, exclude_col, prefix, prefix_downcase, candidates)
+      current_word = +""
+      word_start = 0
+
+      line.each_char.with_index do |char, col|
+        if word_char?(char)
+          current_word << char
+        else
+          check_and_add_word(current_word, word_start, row, col, exclude_row, exclude_col, prefix, prefix_downcase, candidates)
+          current_word = +""
+          word_start = col + 1
+        end
+      end
+
+      # Handle word at end of line
+      check_and_add_word(current_word, word_start, row, line.length, exclude_row, exclude_col, prefix, prefix_downcase, candidates)
+    end
+
+    def check_and_add_word(word, word_start, row, col, exclude_row, exclude_col, prefix, prefix_downcase, candidates)
+      return if word.length < MIN_WORD_LENGTH
+      return if word == prefix
+      return unless word.downcase.start_with?(prefix_downcase)
+
+      # Don't include the word at cursor position
+      at_cursor = row == exclude_row && word_start <= exclude_col && col > exclude_col
+      candidates << word unless at_cursor
+    end
+
+    def word_char?(char)
+      char&.match?(/\w/)
+    end
+  end
+end

data/lib/mui/color_manager.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Mui
+  class ColorManager
+    # Standard 8 colors
+    COLOR_MAP = {
+      black: 0,
+      red: 1,
+      green: 2,
+      yellow: 3,
+      blue: 4,
+      magenta: 5,
+      cyan: 6,
+      white: 7
+    }.freeze
+
+    # 256-color palette extended colors
+    # Use https://www.ditig.com/256-colors-cheat-sheet for reference
+    EXTENDED_COLOR_MAP = {
+      # mui theme
+      darkgray: 235, # #262626 (~#2b2b2b)
+
+      # solarized
+      solarized_base03: 234,   # #1c1c1c (~#002b36)
+      solarized_base02: 235,   # #262626 (~#073642)
+      solarized_base01: 240,   # #585858 (~#586e75)
+      solarized_base00: 241,   # #626262 (~#657b83)
+      solarized_base0: 244,    # #808080 (~#839496)
+      solarized_base1: 245,    # #8a8a8a (~#93a1a1)
+      solarized_base2: 254,    # #e4e4e4 (~#eee8d5)
+      solarized_base3: 230,    # #ffffd7 (~#fdf6e3)
+      solarized_yellow: 136,   # #af8700 (~#b58900)
+      solarized_orange: 166,   # #d75f00 (~#cb4b16)
+      solarized_red: 160,      # #d70000 (~#dc322f)
+      solarized_magenta: 125,  # #af005f (~#d33682)
+      solarized_violet: 61,    # #5f5faf (~#6c71c4)
+      solarized_blue: 33,      # #0087ff (~#268bd2)
+      solarized_cyan: 37,      # #00afaf (~#2aa198)
+      solarized_green: 64,     # #5f8700 (~#859900)
+
+      # monokai
+      monokai_bg: 235,         # #262626 (~#272822)
+      monokai_fg: 231,         # #ffffff (~#f8f8f2)
+      monokai_pink: 197,       # #ff005f (~#f92672)
+      monokai_green: 148,      # #afd700 (~#a6e22e)
+      monokai_orange: 208,     # #ff8700 (~#fd971f)
+      monokai_purple: 141,     # #af87ff (~#ae81ff)
+      monokai_cyan: 81,        # #5fd7ff (~#66d9ef)
+      monokai_yellow: 186,     # #d7d787 (~#e6db74)
+
+      # nord
+      nord_polar0: 236,        # #303030 (~#2e3440)
+      nord_polar1: 238,        # #444444 (~#3b4252)
+      nord_polar2: 239,        # #4e4e4e (~#434c5e)
+      nord_polar3: 240,        # #585858 (~#4c566a)
+      nord_snow0: 253,         # #dadada (~#d8dee9)
+      nord_snow1: 254,         # #e4e4e4 (~#e5e9f0)
+      nord_snow2: 255,         # #eeeeee (~#eceff4)
+      nord_frost0: 109,        # #87afaf (~#8fbcbb)
+      nord_frost1: 110,        # #87afd7 (~#88c0d0)
+      nord_frost2: 111,        # #87afff (~#81a1c1)
+      nord_frost3: 68,         # #5f87d7 (~#5e81ac)
+      nord_aurora_red: 167,    # #d75f5f (~#bf616a)
+      nord_aurora_orange: 208, # #ff8700 (~#d08770)
+      nord_aurora_yellow: 179, # #d7af5f (~#ebcb8b)
+      nord_aurora_green: 108,  # #87af87 (~#a3be8c)
+      nord_aurora_purple: 139, # #af87af (~#b48ead)
+
+      # gruvbox
+      gruvbox_bg: 235,         # #262626 (~#282828)
+      gruvbox_fg: 223,         # #ffd7af (~#ebdbb2)
+      gruvbox_red: 124,        # #af0000 (~#cc241d)
+      gruvbox_green: 106,      # #87af00 (~#98971a)
+      gruvbox_yellow: 172,     # #d78700 (~#d79921)
+      gruvbox_blue: 66,        # #5f8787 (~#458588)
+      gruvbox_purple: 132,     # #af5f87 (~#b16286)
+      gruvbox_aqua: 72,        # #5faf87 (~#689d6a)
+      gruvbox_orange: 166,     # #d75f00 (~#d65d0e)
+      gruvbox_gray: 245,       # #8a8a8a (~#928374)
+
+      # dracula
+      dracula_bg: 236,         # #303030 (~#282a36)
+      dracula_fg: 231,         # #ffffff (~#f8f8f2)
+      dracula_selection: 239,  # #4e4e4e (~#44475a)
+      dracula_comment: 61,     # #5f5faf (~#6272a4)
+      dracula_cyan: 117,       # #87d7ff (~#8be9fd)
+      dracula_green: 84,       # #5fdf5f (~#50fa7b)
+      dracula_orange: 215,     # #ffaf5f (~#ffb86c)
+      dracula_pink: 212,       # #ff87d7 (~#ff79c6)
+      dracula_purple: 141,     # #af87ff (~#bd93f9)
+      dracula_red: 203,        # #ff5f5f (~#ff5555)
+      dracula_yellow: 228,     # #ffff87 (~#f1fa8c)
+
+      # tokyo night
+      tokyo_bg: 234,           # #1c1c1c (~#1a1b26)
+      tokyo_fg: 146,           # #afafd7 (~#a9b1d6)
+      tokyo_comment: 60,       # #5f5f87 (~#565f89)
+      tokyo_cyan: 115,         # #87d7af (~#7dcfff)
+      tokyo_blue: 75,          # #5fafff (~#7aa2f7)
+      tokyo_purple: 140,       # #af87d7 (~#bb9af7)
+      tokyo_green: 108,        # #87af87 (~#9ece6a)
+      tokyo_orange: 215,       # #ffaf5f (~#ff9e64)
+      tokyo_red: 203,          # #ff5f5f (~#f7768e)
+      tokyo_yellow: 223        # #ffd7af (~#e0af68)
+    }.freeze
+
+    attr_reader :pairs
+
+    def initialize
+      @pair_index = 1
+      @pairs = {}
+    end
+
+    def register_pair(fg, bg)
+      key = [fg, bg]
+      return @pairs[key] if @pairs[key]
+
+      @pairs[key] = @pair_index
+      @pair_index += 1
+      @pairs[key]
+    end
+
+    def get_pair_index(fg, bg)
+      register_pair(fg, bg)
+    end
+
+    def color_code(color)
+      return -1 if color.nil?
+      return color if color.is_a?(Integer)
+
+      COLOR_MAP[color] || EXTENDED_COLOR_MAP[color] || -1
+    end
+
+    alias resolve color_code
+  end
+end

data/lib/mui/color_scheme.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Mui
+  class ColorScheme
+    ELEMENTS = %i[
+      normal
+      status_line
+      status_line_mode
+      search_highlight
+      visual_selection
+      line_number
+      message_error
+      message_info
+      tab_bar
+      tab_bar_active
+      completion_popup
+      completion_popup_selected
+      syntax_keyword
+      syntax_string
+      syntax_comment
+      syntax_number
+      syntax_symbol
+      syntax_constant
+      syntax_operator
+      syntax_identifier
+      syntax_preprocessor
+      syntax_instance_variable
+      syntax_global_variable
+      syntax_method_call
+      syntax_type
+      diff_add
+      diff_delete
+      diff_hunk
+      diff_header
+    ].freeze
+
+    attr_reader :name, :colors
+
+    def initialize(name)
+      @name = name
+      @colors = {}
+    end
+
+    def define(element, fg:, bg: nil, bold: false, underline: false)
+      @colors[element] = {
+        fg:,
+        bg:,
+        bold:,
+        underline:
+      }
+    end
+
+    def [](element)
+      @colors[element] || default_color
+    end
+
+    private
+
+    def default_color
+      { fg: :white, bg: nil, bold: false, underline: false }
+    end
+  end
+end

data/lib/mui/command_completer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Mui
+  # Provides command name completion
+  class CommandCompleter
+    COMMANDS = %w[
+      e w q wq q!
+      sp split vs vsplit close only
+      tabnew tabe tabedit tabclose tabc
+      tabnext tabn tabprev tabp tabprevious
+      tabfirst tabf tabrewind tabr tablast tabl
+      tabmove tabm
+    ].freeze
+
+    def complete(prefix)
+      all_commands = COMMANDS + plugin_command_names
+
+      return all_commands.uniq.sort if prefix.empty?
+
+      prefix_downcase = prefix.downcase
+      all_commands.select { |cmd| cmd.downcase.start_with?(prefix_downcase) }.uniq.sort
+    end
+
+    private
+
+    def plugin_command_names
+      Mui.config.commands.keys.map(&:to_s)
+    end
+  end
+end