mui 0.1.0 → 0.2.0

data/lib/mui/plugin.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Mui
+  # Base class for class-based plugins
+  class Plugin
+    class << self
+      attr_accessor :plugin_name, :plugin_dependencies
+
+      def name(n)
+        @plugin_name = n
+      end
+
+      def depends_on(*deps)
+        @plugin_dependencies = deps
+      end
+    end
+
+    def setup
+      # Override in subclass: plugin initialization
+    end
+
+    # API shortcuts
+    def command(name, &)
+      Mui.command(name, &)
+    end
+
+    def keymap(mode, key, &)
+      Mui.keymap(mode, key, &)
+    end
+
+    def autocmd(event, pattern: nil, &)
+      Mui.autocmd(event, pattern:, &)
+    end
+  end
+end

data/lib/mui/plugin_manager.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+module Mui
+  # Manages plugin lifecycle: loading, initialization, dependency resolution
+  class PluginManager
+    attr_reader :plugins, :loaded_plugins, :pending_gems
+
+    def initialize
+      @plugins = {}           # Registered plugin definitions (DSL/class)
+      @loaded_plugins = []    # Loaded plugin names
+      @pending_gems = []      # Gems waiting to be installed
+      @installed = false
+    end
+
+    # Called from Mui.use - register gem (don't install yet)
+    def add_gem(gem_name, version = nil)
+      @pending_gems << { gem: gem_name, version: }
+    end
+
+    # Register plugin definition (DSL or class)
+    def register(name, plugin_class_or_block, dependencies: [])
+      @plugins[name.to_sym] = {
+        handler: plugin_class_or_block,
+        dependencies: dependencies.map(&:to_sym)
+      }
+    end
+
+    # Called during Editor initialization - install and load all at once
+    def install_and_load
+      return if @installed
+
+      install_gems unless @pending_gems.empty?
+      load_all_plugins
+      @installed = true
+    end
+
+    def installed?
+      @installed
+    end
+
+    private
+
+    def install_gems
+      gems = @pending_gems
+      gemfile do
+        source "https://rubygems.org"
+        gems.each do |g|
+          if g[:version]
+            gem g[:gem], g[:version]
+          else
+            gem g[:gem]
+          end
+        end
+      end
+    rescue Bundler::GemNotFound => e
+      warn "Plugin gem not found: #{e.message}"
+    rescue Gem::MissingSpecError => e
+      warn "Plugin gem not found: #{e.message}"
+    end
+
+    def load_all_plugins
+      # Sort by dependencies and load
+      sorted_plugins = topological_sort(@plugins)
+      sorted_plugins.each { |name| load_plugin(name) }
+    end
+
+    def load_plugin(name)
+      return if @loaded_plugins.include?(name)
+
+      plugin_def = @plugins[name]
+      return unless plugin_def
+
+      instance = instantiate_plugin(plugin_def[:handler])
+      instance.setup if instance.respond_to?(:setup)
+      @loaded_plugins << name
+    end
+
+    def instantiate_plugin(handler)
+      case handler
+      when Class
+        handler.new
+      when Proc
+        handler.call
+        nil
+      end
+    end
+
+    def topological_sort(plugins)
+      sorted = []
+      visited = {}
+
+      visit = lambda do |name|
+        return if visited[name]
+
+        visited[name] = true
+        plugins[name]&.[](:dependencies)&.each { |dep| visit.call(dep) }
+        sorted << name
+      end
+
+      plugins.each_key { |name| visit.call(name) }
+      sorted
+    end
+  end
+end

data/lib/mui/register.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages yank/delete registers for copy/paste operations
+  # Supports Vim-compatible registers:
+  # - "" (unnamed): default register
+  # - "a-"z: named registers
+  # - "0: yank register (stores last yank, not affected by delete)
+  # - "1-"9: delete history (shifted on each delete)
+  # - "_: black hole register (discards content)
+  class Register
+    YANK_REGISTER = "0"
+    DELETE_HISTORY_REGISTERS = ("1".."9").to_a.freeze
+    BLACK_HOLE_REGISTER = "_"
+    UNNAMED_REGISTER = '"'
+    NAMED_REGISTERS = ("a".."z").to_a.freeze
+
+    def initialize
+      @unnamed = { content: nil, linewise: false }
+      @yank_register = { content: nil, linewise: false }
+      @delete_history = []
+      @named_registers = {}
+    end
+
+    # Store text from yank operation
+    # Saves to unnamed register and "0 (yank register)
+    def yank(text, linewise: false, name: nil)
+      return if name == BLACK_HOLE_REGISTER
+
+      if name && NAMED_REGISTERS.include?(name)
+        @named_registers[name] = { content: text, linewise: }
+      else
+        @unnamed = { content: text, linewise: }
+        @yank_register = { content: text, linewise: }
+      end
+    end
+
+    # Store text from delete operation
+    # Saves to unnamed register and shifts delete history ("1-"9)
+    def delete(text, linewise: false, name: nil)
+      return if name == BLACK_HOLE_REGISTER
+
+      if name && NAMED_REGISTERS.include?(name)
+        @named_registers[name] = { content: text, linewise: }
+      else
+        @unnamed = { content: text, linewise: }
+        shift_delete_history(text, linewise)
+      end
+    end
+
+    # Legacy method for backward compatibility
+    def set(text, linewise: false, name: nil)
+      if name
+        @named_registers[name] = { content: text, linewise: }
+      else
+        @unnamed = { content: text, linewise: }
+      end
+    end
+
+    def get(name: nil)
+      case name
+      when nil, UNNAMED_REGISTER
+        @unnamed[:content]
+      when YANK_REGISTER
+        @yank_register[:content]
+      when *DELETE_HISTORY_REGISTERS
+        index = name.to_i - 1
+        @delete_history[index]&.fetch(:content, nil)
+      when BLACK_HOLE_REGISTER
+        nil
+      when *NAMED_REGISTERS
+        @named_registers[name]&.fetch(:content, nil)
+      end
+    end
+
+    def linewise?(name: nil)
+      case name
+      when nil, UNNAMED_REGISTER
+        @unnamed[:linewise]
+      when YANK_REGISTER
+        @yank_register[:linewise]
+      when *DELETE_HISTORY_REGISTERS
+        index = name.to_i - 1
+        @delete_history[index]&.fetch(:linewise, false) || false
+      when BLACK_HOLE_REGISTER
+        false
+      when *NAMED_REGISTERS
+        @named_registers[name]&.fetch(:linewise, false) || false
+      else
+        false
+      end
+    end
+
+    def empty?(name: nil)
+      get(name:).nil?
+    end
+
+    # For backward compatibility
+    def linewise
+      @unnamed[:linewise]
+    end
+
+    private
+
+    def shift_delete_history(text, linewise)
+      @delete_history.unshift({ content: text, linewise: })
+      @delete_history = @delete_history.first(9)
+    end
+  end
+end

data/lib/mui/screen.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Mui
+  class Screen
+    attr_reader :width, :height
+
+    def initialize(adapter:, color_manager: nil)
+      @adapter = adapter
+      @color_manager = color_manager
+      @initialized_pairs = {}
+      @adapter.init
+      update_size
+    end
+
+    def refresh
+      update_size
+      @adapter.refresh
+    end
+
+    def close
+      @adapter.close
+    end
+
+    def clear
+      @adapter.clear
+    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)
+    end
+
+    def put_with_highlight(y, x, text)
+      return if y.negative?
+      return if y >= @height || x >= @width
+
+      @adapter.setpos(y, x)
+      max_len = @width - x
+      @adapter.with_highlight do
+        @adapter.addstr(text.length > max_len ? text[0, max_len] : text)
+      end
+    end
+
+    def put_with_style(y, x, text, style)
+      return if y.negative?
+      return if y >= @height || x >= @width
+      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
+
+      pair_index = ensure_color_pair(style[:fg], style[:bg])
+      @adapter.with_color(pair_index, bold: style[:bold], underline: style[:underline]) do
+        @adapter.addstr(truncated_text)
+      end
+    end
+
+    def move_cursor(y, x)
+      x = [[x, 0].max, @width - 1].min
+      y = [[y, 0].max, @height - 1].min
+      @adapter.setpos(y, x)
+    end
+
+    private
+
+    def ensure_color_pair(fg, bg)
+      pair_index = @color_manager.get_pair_index(fg, bg)
+      unless @initialized_pairs[pair_index]
+        @adapter.init_color_pair(pair_index, fg, bg)
+        @initialized_pairs[pair_index] = true
+      end
+      pair_index
+    end
+
+    def update_size
+      @width = @adapter.width
+      @height = @adapter.height
+    end
+  end
+end

data/lib/mui/search_completer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Mui
+  # Extracts search completion candidates from buffer content
+  class SearchCompleter
+    MAX_CANDIDATES = 50
+
+    def initialize
+      @word_cache = {}
+      @cache_buffer_id = nil
+      @cache_version = nil
+    end
+
+    # Extract words from buffer that match the given prefix
+    def complete(buffer, prefix)
+      return [] if prefix.nil? || prefix.empty?
+
+      words = extract_words(buffer)
+      matching = words.select { |word| word.start_with?(prefix) && word != prefix }
+
+      # Sort by length (shorter first) then alphabetically
+      matching.sort_by { |w| [w.length, w] }.take(MAX_CANDIDATES)
+    end
+
+    private
+
+    def extract_words(buffer)
+      # Simple cache invalidation based on buffer identity and modification
+      buffer_id = buffer.object_id
+      version = buffer.lines.hash
+
+      return @word_cache[buffer_id] if @cache_buffer_id == buffer_id && @cache_version == version
+
+      words = Set.new
+      buffer.line_count.times do |row|
+        line = buffer.line(row)
+        # Extract words (alphanumeric + underscore, minimum 2 characters)
+        line.scan(/\b[a-zA-Z_][a-zA-Z0-9_]+\b/) do |word|
+          words.add(word)
+        end
+      end
+
+      @cache_buffer_id = buffer_id
+      @cache_version = version
+      @word_cache[buffer_id] = words.to_a
+
+      @word_cache[buffer_id]
+    end
+  end
+end

data/lib/mui/search_input.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mui
+  class SearchInput
+    attr_reader :buffer, :prompt
+
+    def initialize(prompt = "/")
+      @buffer = ""
+      @prompt = prompt
+    end
+
+    def input(char)
+      @buffer += char
+    end
+
+    def backspace
+      @buffer = @buffer.chop
+    end
+
+    def clear
+      @buffer = ""
+    end
+
+    def set_prompt(prompt)
+      @prompt = prompt
+    end
+
+    def to_s
+      "#{@prompt}#{@buffer}"
+    end
+
+    def pattern
+      @buffer
+    end
+
+    def empty?
+      @buffer.empty?
+    end
+  end
+end

data/lib/mui/search_state.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Mui
+  class SearchState
+    attr_reader :pattern, :direction, :matches
+
+    def initialize
+      @pattern = nil
+      @direction = :forward
+      @matches = []
+    end
+
+    def set_pattern(pattern, direction)
+      @pattern = pattern
+      @direction = direction
+      @matches = []
+    end
+
+    def find_all_matches(buffer)
+      @matches = []
+      return if @pattern.nil? || @pattern.empty?
+
+      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
+    end
+
+    def find_next(current_row, current_col)
+      return nil if @matches.empty?
+
+      # Find next match after current position
+      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
+    end
+
+    def find_previous(current_row, current_col)
+      return nil if @matches.empty?
+
+      # Find previous match before current position
+      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
+    end
+
+    def clear
+      @pattern = nil
+      @matches = []
+    end
+
+    def has_pattern?
+      !@pattern.nil? && !@pattern.empty?
+    end
+
+    def matches_for_row(row)
+      @matches.select { |m| m[:row] == row }
+    end
+
+    private
+
+    def scan_line_matches(line, row, regex)
+      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: }
+        # 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
+    end
+  end
+end

data/lib/mui/selection.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Mui
+  class Selection
+    attr_accessor :start_row, :start_col, :end_row, :end_col
+    attr_reader :line_mode
+
+    def initialize(start_row, start_col, line_mode: false)
+      @start_row = start_row
+      @start_col = start_col
+      @end_row = start_row
+      @end_col = start_col
+      @line_mode = line_mode
+    end
+
+    def update_end(row, col)
+      @end_row = row
+      @end_col = col
+    end
+
+    def normalized_range
+      if @start_row < @end_row || (@start_row == @end_row && @start_col <= @end_col)
+        { start_row: @start_row, start_col: @start_col, end_row: @end_row, end_col: @end_col }
+      else
+        { start_row: @end_row, start_col: @end_col, end_row: @start_row, end_col: @start_col }
+      end
+    end
+
+    def covers_position?(row, col, buffer)
+      range = normalized_range
+
+      if @line_mode
+        row.between?(range[:start_row], range[:end_row])
+      else
+        covers_character_position?(row, col, range, buffer)
+      end
+    end
+
+    private
+
+    def covers_character_position?(row, col, range, _buffer)
+      return false if row < range[:start_row] || row > range[:end_row]
+
+      if range[:start_row] == range[:end_row]
+        col.between?(range[:start_col], range[:end_col])
+      elsif row == range[:start_row]
+        col >= range[:start_col]
+      elsif row == range[:end_row]
+        col <= range[:end_col]
+      else
+        true
+      end
+    end
+  end
+end

data/lib/mui/status_line_renderer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mui
+  class StatusLineRenderer
+    def initialize(buffer, window, color_scheme)
+      @buffer = buffer
+      @window = window
+      @color_scheme = color_scheme
+    end
+
+    def render(screen, y_position)
+      full_status = format_status_line(build_status_text, build_position_text)
+
+      if @color_scheme
+        screen.put_with_style(y_position, @window.x, full_status, @color_scheme[:status_line])
+      else
+        screen.put(y_position, @window.x, full_status)
+      end
+    end
+
+    private
+
+    def build_status_text
+      status = " #{@buffer.name}"
+      status += " [+]" if @buffer.modified
+      status
+    end
+
+    def build_position_text
+      "#{@window.cursor_row + 1}:#{@window.cursor_col + 1} "
+    end
+
+    def format_status_line(status, position)
+      padding = @window.width - status.length - position.length
+      padding = 0 if padding.negative?
+      full_status = status + (" " * padding) + position
+      full_status[0, @window.width]
+    end
+  end
+end

data/lib/mui/syntax/language_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mui
+  module Syntax
+    # Detects programming language from file path and provides appropriate lexer
+    class LanguageDetector
+      # Map file extensions to language symbols
+      EXTENSION_MAP = {
+        ".rb" => :ruby,
+        ".ru" => :ruby,
+        ".rake" => :ruby,
+        ".gemspec" => :ruby,
+        ".c" => :c,
+        ".h" => :c,
+        ".y" => :c
+      }.freeze
+
+      # Map basenames (files without extension) to language symbols
+      BASENAME_MAP = {
+        "Gemfile" => :ruby,
+        "Rakefile" => :ruby,
+        "Guardfile" => :ruby,
+        "Vagrantfile" => :ruby,
+        "Berksfile" => :ruby,
+        "Capfile" => :ruby,
+        "Thorfile" => :ruby,
+        "Podfile" => :ruby,
+        "Brewfile" => :ruby
+      }.freeze
+
+      class << self
+        # Detect language from file path
+        def detect(file_path)
+          return nil if file_path.nil? || file_path.empty?
+
+          # Try extension first
+          ext = File.extname(file_path).downcase
+          language = EXTENSION_MAP[ext]
+          return language if language
+
+          # Try basename
+          basename = File.basename(file_path)
+          BASENAME_MAP[basename]
+        end
+
+        # Get a lexer instance for a language
+        def lexer_for(language)
+          case language
+          when :ruby
+            Lexers::RubyLexer.new
+          when :c
+            Lexers::CLexer.new
+          end
+        end
+
+        # Get a lexer instance for a file path
+        def lexer_for_file(file_path)
+          language = detect(file_path)
+          lexer_for(language)
+        end
+
+        # List all supported languages
+        def supported_languages
+          (EXTENSION_MAP.values + BASENAME_MAP.values).uniq
+        end
+
+        # List all supported extensions
+        def supported_extensions
+          EXTENSION_MAP.keys
+        end
+      end
+    end
+  end
+end