mui 0.1.0 → 0.3.0

data/lib/mui/layout/leaf_node.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Mui
+  module Layout
+    class LeafNode < Node
+      attr_accessor :window
+
+      def initialize(window)
+        super()
+        @window = window
+      end
+
+      def leaf?
+        true
+      end
+
+      def windows
+        [@window]
+      end
+
+      def find_window_node(target_window)
+        @window == target_window ? self : nil
+      end
+
+      def apply_geometry
+        @window.x = @x
+        @window.y = @y
+        @window.width = @width
+        @window.height = @height
+      end
+    end
+  end
+end

data/lib/mui/layout/node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mui
+  module Layout
+    class Node
+      attr_accessor :parent, :x, :y, :width, :height
+
+      def leaf?
+        false
+      end
+
+      def split?
+        false
+      end
+
+      def windows
+        raise Mui::MethodNotOverriddenError, :windows
+      end
+
+      def find_window_node(_window)
+        raise Mui::MethodNotOverriddenError, :find_window_node
+      end
+
+      def apply_geometry
+        raise Mui::MethodNotOverriddenError, :apply_geometry
+      end
+    end
+  end
+end

data/lib/mui/layout/split_node.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Mui
+  module Layout
+    class SplitNode < Node
+      SEPARATOR_SIZE = 1
+
+      attr_accessor :direction, :children, :ratio
+
+      def initialize(direction:, children: [], ratio: 0.5)
+        super()
+        @direction = direction
+        @children = children
+        @ratio = ratio
+        children.each { |c| c.parent = self }
+      end
+
+      def separators
+        result = []
+        collect_separators(result)
+        result
+      end
+
+      def split?
+        true
+      end
+
+      def windows
+        @children.flat_map(&:windows)
+      end
+
+      def find_window_node(target_window)
+        @children.each do |child|
+          result = child.find_window_node(target_window)
+          return result if result
+        end
+        nil
+      end
+
+      def apply_geometry
+        return if @children.empty?
+
+        if @children.size == 1
+          apply_single_child
+        else
+          apply_split_children
+        end
+
+        @children.each(&:apply_geometry)
+      end
+
+      def replace_child(old_child, new_child)
+        index = @children.index(old_child)
+        return unless index
+
+        @children[index] = new_child
+        new_child.parent = self
+      end
+
+      def remove_child(child)
+        @children.delete(child)
+      end
+
+      private
+
+      def apply_single_child
+        child = @children.first
+        child.x = @x
+        child.y = @y
+        child.width = @width
+        child.height = @height
+      end
+
+      def apply_split_children
+        case @direction
+        when :horizontal
+          apply_horizontal_split
+        when :vertical
+          apply_vertical_split
+        end
+      end
+
+      def apply_horizontal_split
+        available_height = @height - SEPARATOR_SIZE
+        first_height = (available_height * @ratio).to_i
+        second_height = available_height - first_height
+
+        @children[0].x = @x
+        @children[0].y = @y
+        @children[0].width = @width
+        @children[0].height = first_height
+
+        @children[1].x = @x
+        @children[1].y = @y + first_height + SEPARATOR_SIZE
+        @children[1].width = @width
+        @children[1].height = second_height
+      end
+
+      def apply_vertical_split
+        available_width = @width - SEPARATOR_SIZE
+        first_width = (available_width * @ratio).to_i
+        second_width = available_width - first_width
+
+        @children[0].x = @x
+        @children[0].y = @y
+        @children[0].width = first_width
+        @children[0].height = @height
+
+        @children[1].x = @x + first_width + SEPARATOR_SIZE
+        @children[1].y = @y
+        @children[1].width = second_width
+        @children[1].height = @height
+      end
+
+      def collect_separators(result)
+        return if @children.size < 2
+
+        if @direction == :horizontal
+          separator_y = @children[0].y + @children[0].height
+          result << { type: :horizontal, x: @x, y: separator_y, length: @width }
+        else
+          separator_x = @children[0].x + @children[0].width
+          result << { type: :vertical, x: separator_x, y: @y, length: @height }
+        end
+
+        @children.each do |child|
+          child.send(:collect_separators, result) if child.respond_to?(:collect_separators, true)
+        end
+      end
+    end
+  end
+end

data/lib/mui/line_renderer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Mui
+  class LineRenderer
+    def initialize(color_scheme)
+      @color_scheme = color_scheme
+      @highlighters = []
+      @resolved_styles = {} # Cache for resolved styles
+    end
+
+    def add_highlighter(highlighter)
+      @highlighters << highlighter
+    end
+
+    def render(screen, line, row, x, y, options = {})
+      highlights = collect_highlights(row, line, options)
+      render_with_highlights(screen, line, x, y, highlights)
+    end
+
+    # Renders a wrapped line segment with screen coordinate-based highlights
+    # wrap_info: { text:, start_col:, end_col: }
+    # options: { selection:, search_state:, logical_row:, visible_width: }
+    def render_wrapped_line(screen, y, x, wrap_info, options = {})
+      text = wrap_info[:text]
+      return if text.nil?
+
+      logical_row = options[:logical_row]
+      start_col = wrap_info[:start_col]
+      end_col = wrap_info[:end_col]
+
+      # Collect highlights for this row and clip to wrapped segment range
+      highlights = collect_highlights(logical_row, text, options)
+      clipped_highlights = clip_highlights_to_range(highlights, start_col, end_col)
+
+      # Adjust highlight positions to be relative to wrap segment start
+      adjusted_highlights = clipped_highlights.map do |h|
+        adjusted_start = h.start_col - start_col
+        adjusted_end = h.end_col - start_col
+        Highlight.new(
+          start_col: adjusted_start,
+          end_col: adjusted_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+
+      render_with_highlights(screen, text, x, y, adjusted_highlights)
+    end
+
+    private
+
+    # Clips highlights to a column range and returns only overlapping portions
+    def clip_highlights_to_range(highlights, range_start, range_end)
+      highlights.filter_map do |h|
+        # Skip if highlight doesn't overlap with range
+        next if h.end_col < range_start || h.start_col >= range_end
+
+        # Clip to range
+        clipped_start = [h.start_col, range_start].max
+        clipped_end = [h.end_col, range_end - 1].min
+
+        next if clipped_start > clipped_end
+
+        Highlight.new(
+          start_col: clipped_start,
+          end_col: clipped_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+    end
+
+    def collect_highlights(row, line, options)
+      @highlighters
+        .flat_map { |h| h.highlights_for(row, line, options) }
+        .sort
+    end
+
+    def render_with_highlights(screen, line, x, y, highlights)
+      if highlights.empty?
+        put_text(screen, y, x, line, :normal)
+        return
+      end
+
+      segments = build_segments(line, highlights)
+      current_x = x
+
+      segments.each do |segment|
+        put_text(screen, y, current_x, segment[:text], segment[:style])
+        current_x += UnicodeWidth.string_width(segment[:text])
+      end
+    end
+
+    def build_segments(line, highlights)
+      segments = []
+      current_pos = 0
+      active_highlights = []
+
+      events = build_events(highlights, line.length)
+
+      events.each do |event|
+        if event[:pos] > current_pos && current_pos < line.length
+          end_pos = [event[:pos], line.length].min
+          style = active_highlights.max_by(&:priority)&.style || :normal
+          text = line[current_pos...end_pos]
+          segments << { text:, style: } unless text.empty?
+          current_pos = end_pos
+        end
+
+        case event[:type]
+        when :start
+          active_highlights << event[:highlight]
+        when :end
+          active_highlights.delete(event[:highlight])
+        end
+      end
+
+      if current_pos < line.length
+        style = active_highlights.max_by(&:priority)&.style || :normal
+        segments << { text: line[current_pos..], style: }
+      end
+
+      segments
+    end
+
+    def build_events(highlights, line_length)
+      return [] if highlights.empty?
+
+      events = []
+      highlights.each do |h|
+        start_col = [h.start_col, 0].max
+        end_col = [h.end_col, line_length - 1].min
+        next if start_col > end_col
+
+        events << [start_col, 1, h] # 1 = start (sorted after end at same position)
+        events << [end_col + 1, 0, h] # 0 = end
+      end
+      # Sort by position, then by type (end before start at same position)
+      events.sort!
+      # Convert back to hash format
+      events.map! { |pos, type, h| { pos:, type: type == 1 ? :start : :end, highlight: h } }
+      events
+    end
+
+    def put_text(screen, y, x, text, style)
+      return if text.nil? || text.empty?
+
+      if @color_scheme && @color_scheme[style]
+        resolved_style = resolve_style(style)
+        screen.put_with_style(y, x, text, resolved_style)
+      else
+        screen.put(y, x, text)
+      end
+    end
+
+    def resolve_style(style)
+      # Use cached resolved style if available
+      return @resolved_styles[style] if @resolved_styles.key?(style)
+
+      style_hash = @color_scheme[style]
+      resolved = if style_hash[:bg]
+                   style_hash
+                 else
+                   # Inherit background from :normal if not specified
+                   normal_style = @color_scheme[:normal]
+                   normal_style ? style_hash.merge(bg: normal_style[:bg]) : style_hash
+                 end
+
+      @resolved_styles[style] = resolved
+      resolved
+    end
+  end
+end

data/lib/mui/mode.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mui
+  module Mode
+    NORMAL = :normal
+    INSERT = :insert
+    COMMAND = :command
+    VISUAL = :visual
+    VISUAL_LINE = :visual_line
+    SEARCH_FORWARD = :search_forward
+    SEARCH_BACKWARD = :search_backward
+  end
+end

data/lib/mui/mode_manager.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages editor mode state and transitions
+  class ModeManager
+    attr_reader :mode, :selection, :register, :undo_manager, :search_state, :search_input, :editor,
+                :last_visual_selection, :key_sequence_handler
+
+    def initialize(window:, buffer:, command_line:, undo_manager: nil, editor: nil, register: nil, key_sequence_handler: nil)
+      @tab_manager = window.is_a?(TabManager) ? window : nil
+      @window_manager = window.is_a?(WindowManager) ? window : nil
+      @window = !@tab_manager && !@window_manager ? window : nil
+      @buffer = buffer
+      @command_line = command_line
+      @register = register || Mui.register
+      @undo_manager = undo_manager
+      @editor = editor
+      @key_sequence_handler = key_sequence_handler
+      @search_state = SearchState.new
+      @search_input = SearchInput.new
+      @mode = Mode::NORMAL
+      @selection = nil
+      @visual_handler = nil
+      @last_visual_selection = nil
+
+      initialize_key_handlers
+    end
+
+    def window_manager
+      @tab_manager&.window_manager || @window_manager
+    end
+
+    def current_handler
+      if visual_mode?
+        @visual_handler || @key_handlers[Mode::NORMAL]
+      else
+        @key_handlers[@mode]
+      end
+    end
+
+    def transition(result)
+      return unless result.mode
+
+      clear_visual_mode if result.clear_selection?
+
+      case result.mode
+      when Mode::VISUAL, Mode::VISUAL_LINE
+        handle_visual_transition(result)
+      when Mode::INSERT
+        handle_insert_transition(result)
+      when Mode::SEARCH_FORWARD
+        handle_search_forward_transition
+      when Mode::SEARCH_BACKWARD
+        handle_search_backward_transition
+      else
+        @mode = result.mode
+      end
+    end
+
+    def visual_mode?
+      @mode == Mode::VISUAL || @mode == Mode::VISUAL_LINE
+    end
+
+    def active_window
+      @tab_manager&.active_window || @window_manager&.active_window || @window
+    end
+
+    alias window active_window
+
+    def restore_visual_selection
+      return unless @last_visual_selection
+
+      line_mode = @last_visual_selection[:line_mode]
+      @mode = line_mode ? Mode::VISUAL_LINE : Mode::VISUAL
+      @selection = Selection.new(
+        @last_visual_selection[:start_row],
+        @last_visual_selection[:start_col],
+        line_mode:
+      )
+      @selection.update_end(
+        @last_visual_selection[:end_row],
+        @last_visual_selection[:end_col]
+      )
+      @visual_handler = if line_mode
+                          KeyHandler::VisualLineMode.new(self, @buffer, @selection, @register, undo_manager: @undo_manager)
+                        else
+                          KeyHandler::VisualMode.new(self, @buffer, @selection, @register, undo_manager: @undo_manager)
+                        end
+
+      # Move cursor to end of selection
+      active_window.cursor_row = @last_visual_selection[:end_row]
+      active_window.cursor_col = @last_visual_selection[:end_col]
+    end
+
+    private
+
+    def initialize_key_handlers
+      @key_handlers = {
+        Mode::NORMAL => KeyHandler::NormalMode.new(self, @buffer, @register, undo_manager: @undo_manager, search_state: @search_state),
+        # Use group_started: true to prevent begin_group on initialization
+        # The handler will be replaced when actually entering Insert mode
+        Mode::INSERT => KeyHandler::InsertMode.new(self, @buffer, undo_manager: @undo_manager, group_started: true),
+        Mode::COMMAND => KeyHandler::CommandMode.new(self, @buffer, @command_line),
+        Mode::SEARCH_FORWARD => KeyHandler::SearchMode.new(self, @buffer, @search_input, @search_state),
+        Mode::SEARCH_BACKWARD => KeyHandler::SearchMode.new(self, @buffer, @search_input, @search_state)
+      }
+    end
+
+    def create_insert_handler(group_started: false)
+      KeyHandler::InsertMode.new(self, @buffer, undo_manager: @undo_manager, group_started:)
+    end
+
+    def handle_insert_transition(result)
+      group_started = result.respond_to?(:group_started?) && result.group_started?
+      @key_handlers[Mode::INSERT] = create_insert_handler(group_started:)
+      @mode = Mode::INSERT
+    end
+
+    def handle_visual_transition(result)
+      if result.start_selection?
+        start_visual_mode(result.mode, result.line_mode?)
+      elsif result.toggle_line_mode?
+        toggle_visual_line_mode(result.mode)
+      else
+        @mode = result.mode
+      end
+    end
+
+    def start_visual_mode(mode, line_mode)
+      @mode = mode
+      @visual_handler = create_visual_handler(line_mode:)
+    end
+
+    def clear_visual_mode
+      save_visual_selection if @selection
+      @selection = nil
+      @visual_handler = nil
+    end
+
+    def save_visual_selection
+      return unless @selection
+
+      @last_visual_selection = {
+        start_row: @selection.start_row,
+        start_col: @selection.start_col,
+        end_row: @selection.end_row,
+        end_col: @selection.end_col,
+        line_mode: @selection.line_mode
+      }
+    end
+
+    def toggle_visual_line_mode(new_mode)
+      return unless @selection
+
+      new_line_mode = new_mode == Mode::VISUAL_LINE
+      @selection = Selection.new(@selection.start_row, @selection.start_col, line_mode: new_line_mode)
+      @selection.update_end(active_window.cursor_row, active_window.cursor_col)
+      @visual_handler = create_visual_handler(line_mode: new_line_mode)
+      @mode = new_mode
+    end
+
+    def create_visual_handler(line_mode:)
+      @selection = Selection.new(active_window.cursor_row, active_window.cursor_col, line_mode:)
+
+      if line_mode
+        KeyHandler::VisualLineMode.new(self, @buffer, @selection, @register, undo_manager: @undo_manager)
+      else
+        KeyHandler::VisualMode.new(self, @buffer, @selection, @register, undo_manager: @undo_manager)
+      end
+    end
+
+    def handle_search_forward_transition
+      @search_input.clear
+      @search_input.set_prompt("/")
+      @key_handlers[Mode::SEARCH_FORWARD].start_search
+      @mode = Mode::SEARCH_FORWARD
+    end
+
+    def handle_search_backward_transition
+      @search_input.clear
+      @search_input.set_prompt("?")
+      @key_handlers[Mode::SEARCH_BACKWARD].start_search
+      @mode = Mode::SEARCH_BACKWARD
+    end
+  end
+end

data/lib/mui/motion.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Mui
+  module Motion
+    WORD_CHARS = /[a-zA-Z0-9_]/
+
+    class << self
+      # Basic movements
+      def left(_buffer, row, col)
+        col.positive? ? { row:, col: col - 1 } : nil
+      end
+
+      def right(buffer, row, col)
+        line = buffer.line(row)
+        col < line.size - 1 ? { row:, col: col + 1 } : nil
+      end
+
+      def up(_buffer, row, col)
+        row.positive? ? { row: row - 1, col: } : nil
+      end
+
+      def down(buffer, row, col)
+        row < buffer.line_count - 1 ? { row: row + 1, col: } : nil
+      end
+
+      # Word movements
+      def word_forward(buffer, row, col)
+        line = buffer.line(row)
+
+        # Move past current word
+        col += 1 while col < line.size && line[col] =~ WORD_CHARS
+
+        # Skip whitespace
+        col += 1 while col < line.size && line[col] =~ /\s/
+
+        # If at end of line, move to next line
+        if col >= line.size && row < buffer.line_count - 1
+          next_line = buffer.line(row + 1)
+          # Find first non-whitespace character on next line
+          next_col = 0
+          next_col += 1 while next_col < next_line.size && next_line[next_col] =~ /\s/
+          return { row: row + 1, col: next_col }
+        end
+
+        { row:, col: }
+      end
+
+      def word_backward(buffer, row, col)
+        buffer.line(row)
+
+        # If at start of line, go to previous line
+        if col.zero? && row.positive?
+          prev_line = buffer.line(row - 1)
+          return word_backward(buffer, row - 1, prev_line.size)
+        end
+
+        # Move back one position to check previous character
+        col -= 1 if col.positive?
+        line = buffer.line(row)
+
+        # Skip whitespace
+        col -= 1 while col.positive? && line[col] =~ /\s/
+
+        # Move to start of word
+        col -= 1 while col.positive? && line[col - 1] =~ WORD_CHARS
+
+        { row:, col: }
+      end
+
+      def word_end(buffer, row, col)
+        line = buffer.line(row)
+
+        # Move forward one position
+        col += 1 if col < line.size
+
+        # Skip whitespace
+        col += 1 while col < line.size && line[col] =~ /\s/
+
+        # If at end of line, move to next line
+        return word_end(buffer, row + 1, 0) if col >= line.size && row < buffer.line_count - 1
+
+        # Move to end of word
+        col += 1 while col < line.size - 1 && line[col + 1] =~ WORD_CHARS
+
+        { row:, col: }
+      end
+
+      # Line start/end movements
+      def line_start(_buffer, row, _col)
+        { row:, col: 0 }
+      end
+
+      def first_non_blank(buffer, row, _col)
+        line = buffer.line(row)
+        new_col = line.index(/\S/) || 0
+        { row:, col: new_col }
+      end
+
+      def line_end(buffer, row, _col)
+        line = buffer.line(row)
+        { row:, col: [line.size - 1, 0].max }
+      end
+
+      # File start/end movements
+      def file_start(_buffer, _row, _col)
+        { row: 0, col: 0 }
+      end
+
+      def file_end(buffer, _row, _col)
+        last_row = buffer.line_count - 1
+        { row: last_row, col: 0 }
+      end
+
+      # Character search (f, F, t, T)
+      def find_char_forward(buffer, row, col, char)
+        line = buffer.line(row)
+        index = line.index(char, col + 1)
+        index ? { row:, col: index } : nil
+      end
+
+      def find_char_backward(buffer, row, col, char)
+        line = buffer.line(row)
+        search_range = line[0...col]
+        index = search_range.rindex(char)
+        index ? { row:, col: index } : nil
+      end
+
+      def till_char_forward(buffer, row, col, char)
+        result = find_char_forward(buffer, row, col, char)
+        result ? { row: result[:row], col: result[:col] - 1 } : nil
+      end
+
+      def till_char_backward(buffer, row, col, char)
+        result = find_char_backward(buffer, row, col, char)
+        result ? { row: result[:row], col: result[:col] + 1 } : nil
+      end
+    end
+  end
+end