mui 0.1.0 → 0.2.0

data/lib/mui/undoable_action.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Mui
+  # Base class for undoable actions
+  class UndoableAction
+    def execute(buffer); end
+    def undo(buffer); end
+  end
+
+  # Insert a single character
+  class InsertCharAction < UndoableAction
+    def initialize(row, col, char)
+      super()
+      @row = row
+      @col = col
+      @char = char
+    end
+
+    def execute(buffer)
+      buffer.insert_char_without_record(@row, @col, @char)
+    end
+
+    def undo(buffer)
+      buffer.delete_char_without_record(@row, @col)
+    end
+  end
+
+  # Delete a single character
+  class DeleteCharAction < UndoableAction
+    def initialize(row, col, char)
+      super()
+      @row = row
+      @col = col
+      @char = char
+    end
+
+    def execute(buffer)
+      buffer.delete_char_without_record(@row, @col)
+    end
+
+    def undo(buffer)
+      buffer.insert_char_without_record(@row, @col, @char)
+    end
+  end
+
+  # Insert a line
+  class InsertLineAction < UndoableAction
+    def initialize(row, text)
+      super()
+      @row = row
+      @text = text
+    end
+
+    def execute(buffer)
+      buffer.insert_line_without_record(@row, @text)
+    end
+
+    def undo(buffer)
+      buffer.delete_line_without_record(@row)
+    end
+  end
+
+  # Delete a line
+  class DeleteLineAction < UndoableAction
+    def initialize(row, text)
+      super()
+      @row = row
+      @text = text
+    end
+
+    def execute(buffer)
+      buffer.delete_line_without_record(@row)
+    end
+
+    def undo(buffer)
+      buffer.insert_line_without_record(@row, @text)
+    end
+  end
+
+  # Split a line (Enter key)
+  class SplitLineAction < UndoableAction
+    def initialize(row, col)
+      super()
+      @row = row
+      @col = col
+    end
+
+    def execute(buffer)
+      buffer.split_line_without_record(@row, @col)
+    end
+
+    def undo(buffer)
+      buffer.join_lines_without_record(@row)
+    end
+  end
+
+  # Join lines (Backspace at line start)
+  class JoinLinesAction < UndoableAction
+    def initialize(row, col)
+      super()
+      @row = row
+      @col = col
+    end
+
+    def execute(buffer)
+      buffer.join_lines_without_record(@row)
+    end
+
+    def undo(buffer)
+      buffer.split_line_without_record(@row, @col)
+    end
+  end
+
+  # Delete a range of text
+  class DeleteRangeAction < UndoableAction
+    def initialize(start_row, start_col, end_row, end_col, deleted_lines)
+      super()
+      @start_row = start_row
+      @start_col = start_col
+      @end_row = end_row
+      @end_col = end_col
+      @deleted_lines = deleted_lines
+    end
+
+    def execute(buffer)
+      buffer.delete_range_without_record(@start_row, @start_col, @end_row, @end_col)
+    end
+
+    def undo(buffer)
+      buffer.restore_range(@start_row, @start_col, @deleted_lines)
+    end
+  end
+
+  # Replace line content (for cc command)
+  class ReplaceLineAction < UndoableAction
+    def initialize(row, old_text, new_text)
+      super()
+      @row = row
+      @old_text = old_text
+      @new_text = new_text
+    end
+
+    def execute(buffer)
+      buffer.replace_line_without_record(@row, @new_text)
+    end
+
+    def undo(buffer)
+      buffer.replace_line_without_record(@row, @old_text)
+    end
+  end
+
+  # Group multiple actions into one undo unit
+  class GroupAction < UndoableAction
+    def initialize(actions)
+      super()
+      @actions = actions
+    end
+
+    def execute(buffer)
+      @actions.each { |action| action.execute(buffer) }
+    end
+
+    def undo(buffer)
+      @actions.reverse_each { |action| action.undo(buffer) }
+    end
+
+    def empty?
+      @actions.empty?
+    end
+
+    def size
+      @actions.size
+    end
+  end
+end

data/lib/mui/unicode_width.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Mui
+  # Utility module for calculating display width of Unicode characters
+  # CJK characters and some other characters are "wide" (2 cells)
+  module UnicodeWidth
+    class << self
+      # Returns the display width of a single character
+      def char_width(char)
+        return 0 if char.nil? || char.empty?
+
+        ord = char.ord
+
+        # Control characters
+        return 0 if ord < 32
+
+        # ASCII printable characters
+        return 1 if ord < 127
+
+        # Non-printable
+        return 0 if ord == 127
+
+        # Wide characters (East Asian Wide and Fullwidth)
+        return 2 if wide_char?(ord)
+
+        # Default to 1 for other characters
+        1
+      end
+
+      # Returns the display width of a string
+      def string_width(str)
+        return 0 if str.nil?
+
+        str.chars.sum { |c| char_width(c) }
+      end
+
+      # Returns the display width of a substring from index 0 to col (exclusive)
+      def width_to_col(str, col)
+        return 0 if str.nil? || col <= 0
+
+        str.chars.take(col).sum { |c| char_width(c) }
+      end
+
+      # Returns the character index for a given display width position
+      def col_at_width(str, target_width)
+        return 0 if str.nil? || target_width <= 0
+
+        current_width = 0
+        str.chars.each_with_index do |char, index|
+          return index if current_width >= target_width
+
+          current_width += char_width(char)
+        end
+        str.length
+      end
+
+      private
+
+      def wide_char?(ord)
+        # CJK ranges (simplified, covers most common cases)
+        # Full implementation would use Unicode East Asian Width property
+
+        # Hangul Jamo
+        return true if ord.between?(0x1100, 0x115F)
+
+        # CJK Radicals Supplement to Enclosed CJK Letters
+        return true if ord.between?(0x2E80, 0x4DBF)
+
+        # CJK Unified Ideographs
+        return true if ord.between?(0x4E00, 0x9FFF)
+
+        # Hangul Syllables
+        return true if ord.between?(0xAC00, 0xD7AF)
+
+        # CJK Compatibility Ideographs
+        return true if ord.between?(0xF900, 0xFAFF)
+
+        # Fullwidth Forms
+        return true if ord.between?(0xFF00, 0xFF60)
+
+        # CJK Unified Ideographs Extension B-F
+        return true if ord.between?(0x20000, 0x2FA1F)
+
+        # Halfwidth Katakana (narrow, actually 1)
+        return false if ord.between?(0xFF61, 0xFFDC)
+
+        # Japanese Hiragana
+        return true if ord.between?(0x3040, 0x309F)
+
+        # Japanese Katakana
+        return true if ord.between?(0x30A0, 0x30FF)
+
+        # CJK Symbols and Punctuation
+        return true if ord.between?(0x3000, 0x303F)
+
+        false
+      end
+    end
+  end
+end

data/lib/mui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mui
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/mui/window.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Mui
+  class Window
+    attr_accessor :x, :y, :width, :height, :cursor_row, :cursor_col, :scroll_row, :scroll_col
+    attr_reader :buffer
+
+    def initialize(buffer, x: 0, y: 0, width: 80, height: 24, color_scheme: nil)
+      @buffer = buffer
+      @x = x
+      @y = y
+      @width = width
+      @height = height
+      @cursor_row = 0
+      @cursor_col = 0
+      @scroll_row = 0
+      @scroll_col = 0
+      @color_scheme = color_scheme
+      @syntax_highlighter = Highlighters::SyntaxHighlighter.new(color_scheme, buffer:)
+      @line_renderer = create_line_renderer
+      @status_line_renderer = StatusLineRenderer.new(buffer, self, color_scheme)
+    end
+
+    def buffer=(new_buffer)
+      @buffer = new_buffer
+      @cursor_row = 0
+      @cursor_col = 0
+      @scroll_row = 0
+      @scroll_col = 0
+      @syntax_highlighter.buffer = new_buffer
+      @line_renderer = create_line_renderer
+      @status_line_renderer = StatusLineRenderer.new(new_buffer, self, @color_scheme)
+    end
+
+    def visible_height
+      @height - 1 # Status line only (command line is shared by all windows)
+    end
+
+    def visible_width
+      @width
+    end
+
+    def ensure_cursor_visible
+      # 縦スクロール
+      if @cursor_row < @scroll_row
+        @scroll_row = @cursor_row
+      elsif @cursor_row >= @scroll_row + visible_height
+        @scroll_row = @cursor_row - visible_height + 1
+      end
+
+      # 横スクロール
+      if @cursor_col < @scroll_col
+        @scroll_col = @cursor_col
+      elsif @cursor_col >= @scroll_col + visible_width
+        @scroll_col = @cursor_col - visible_width + 1
+      end
+    end
+
+    def render(screen, selection: nil, search_state: nil)
+      options = build_render_options(selection, search_state)
+
+      visible_height.times do |i|
+        row = @scroll_row + i
+        render_line(screen, row, i, options)
+      end
+
+      @status_line_renderer.render(screen, @y + visible_height)
+    end
+
+    def render_line(screen, row, screen_row, options)
+      line = prepare_visible_line(row)
+      adjusted_options = adjust_options_for_scroll(options)
+      @line_renderer.render(screen, line, row, @x, @y + screen_row, adjusted_options)
+    end
+
+    def screen_cursor_x
+      line = @buffer.line(@cursor_row) || ""
+      # Calculate display width from scroll_col to cursor_col
+      visible_text = line[@scroll_col...@cursor_col] || ""
+      @x + UnicodeWidth.string_width(visible_text)
+    end
+
+    def screen_cursor_y
+      @y + @cursor_row - @scroll_row
+    end
+
+    # カーソル移動
+    def move_left
+      @cursor_col -= 1 if @cursor_col.positive?
+    end
+
+    def move_right
+      @cursor_col += 1 if @cursor_col < max_cursor_col
+    end
+
+    def move_up
+      @cursor_row -= 1 if @cursor_row.positive?
+      clamp_cursor_col
+    end
+
+    def move_down
+      @cursor_row += 1 if @cursor_row < @buffer.line_count - 1
+      clamp_cursor_col
+    end
+
+    def clamp_cursor_to_line(buffer)
+      max_col = [buffer.line(@cursor_row).length - 1, 0].max
+      @cursor_col = max_col if @cursor_col > max_col
+    end
+
+    # Refresh highlighters (call when custom highlighters change)
+    def refresh_highlighters
+      @line_renderer = create_line_renderer
+    end
+
+    private
+
+    def create_line_renderer
+      renderer = LineRenderer.new(@color_scheme)
+      renderer.add_highlighter(@syntax_highlighter)
+      renderer.add_highlighter(Highlighters::SelectionHighlighter.new(@color_scheme))
+      renderer.add_highlighter(Highlighters::SearchHighlighter.new(@color_scheme))
+
+      # Add buffer-specific custom highlighters
+      @buffer.custom_highlighters(@color_scheme).each do |highlighter|
+        renderer.add_highlighter(highlighter)
+      end
+
+      renderer
+    end
+
+    def prepare_visible_line(row)
+      line = @buffer.line(row)
+      visible_line = @scroll_col < line.length ? line[@scroll_col, visible_width] || "" : ""
+      visible_line.ljust(visible_width)
+    end
+
+    def build_render_options(selection, search_state)
+      { selection:, search_state:, scroll_col: @scroll_col, buffer: @buffer }
+    end
+
+    def adjust_options_for_scroll(options)
+      return options unless options[:selection] || options[:search_state]
+
+      adjusted = options.dup
+      adjusted[:scroll_col] = @scroll_col
+      adjusted
+    end
+
+    def max_cursor_col
+      [@buffer.line(@cursor_row).length - 1, 0].max
+    end
+
+    def clamp_cursor_col
+      @cursor_col = max_cursor_col if @cursor_col > max_cursor_col
+    end
+  end
+end

data/lib/mui/window_manager.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Mui
+  class WindowManager
+    # Predicates for determining if a window is in a given direction from another
+    DIRECTION_PREDICATES = {
+      left: ->(w, active) { w.x + w.width <= active.x },
+      right: ->(w, active) { w.x >= active.x + active.width },
+      up: ->(w, active) { w.y + w.height <= active.y },
+      down: ->(w, active) { w.y >= active.y + active.height }
+    }.freeze
+
+    attr_reader :active_window, :layout_root
+
+    def initialize(screen, color_scheme: nil)
+      @screen = screen
+      @color_scheme = color_scheme
+      @active_window = nil
+      @layout_root = nil
+      @layout_calculator = Layout::Calculator.new
+    end
+
+    def add_window(buffer)
+      window = create_window(buffer)
+
+      @layout_root = Layout::LeafNode.new(window) if @layout_root.nil?
+
+      @active_window ||= window
+      update_layout
+      window
+    end
+
+    def remove_window(window)
+      return false if single_window?
+
+      node = @layout_root.find_window_node(window)
+      return false unless node
+
+      remove_node(node)
+
+      @active_window = windows.first if @active_window == window
+      update_layout
+      true
+    end
+
+    def split_horizontal(buffer = nil)
+      split(:horizontal, buffer)
+    end
+
+    def split_vertical(buffer = nil)
+      split(:vertical, buffer)
+    end
+
+    def close_current_window
+      return false if single_window?
+
+      current_node = @layout_root.find_window_node(@active_window)
+      return false unless current_node
+
+      remove_node(current_node)
+
+      @active_window = windows.first
+      update_layout
+      true
+    end
+
+    def close_all_except_current
+      return if single_window?
+
+      @layout_root = Layout::LeafNode.new(@active_window)
+      @layout_root.parent = nil
+      update_layout
+    end
+
+    def render_all(screen, selection: nil, search_state: nil)
+      windows.each do |window|
+        window_selection = window == @active_window ? selection : nil
+        window.render(screen, selection: window_selection, search_state:)
+      end
+      render_separators(screen)
+    end
+
+    def separators
+      return [] unless @layout_root.respond_to?(:separators)
+
+      @layout_root.separators
+    end
+
+    def update_sizes
+      update_layout
+    end
+
+    def focus_next
+      focus_cycle(1)
+    end
+
+    def focus_previous
+      focus_cycle(-1)
+    end
+
+    def focus_direction(direction)
+      return unless windows.size > 1
+
+      target = find_window_in_direction(direction)
+      @active_window = target if target
+    end
+
+    def windows
+      return [] unless @layout_root
+
+      @layout_root.windows
+    end
+
+    def window_count
+      windows.size
+    end
+
+    def single_window?
+      windows.size <= 1
+    end
+
+    def update_layout(y_offset: 0)
+      return unless @layout_root
+
+      @layout_calculator.calculate(
+        @layout_root, 0, y_offset, @screen.width, @screen.height - 1 - y_offset
+      )
+    end
+
+    private
+
+    def focus_cycle(offset)
+      all_windows = windows
+      return if all_windows.size <= 1
+
+      current_index = all_windows.index(@active_window) || 0
+      @active_window = all_windows[(current_index + offset) % all_windows.size]
+    end
+
+    def split(direction, buffer)
+      return nil unless @active_window
+
+      target_buffer = buffer || @active_window.buffer
+      new_window = create_window(target_buffer)
+
+      current_node = @layout_root.find_window_node(@active_window)
+      return nil unless current_node
+
+      parent = current_node.parent
+
+      new_leaf = Layout::LeafNode.new(new_window)
+      split_node = Layout::SplitNode.new(
+        direction:,
+        children: [current_node, new_leaf],
+        ratio: 0.5
+      )
+
+      if parent
+        parent.replace_child(current_node, split_node)
+      else
+        @layout_root = split_node
+      end
+
+      @active_window = new_window
+      update_layout
+      new_window
+    end
+
+    def remove_node(node)
+      parent = node.parent
+      return false unless parent
+
+      parent.remove_child(node)
+
+      if parent.children.size == 1
+        remaining_child = parent.children.first
+        grandparent = parent.parent
+
+        if grandparent
+          grandparent.replace_child(parent, remaining_child)
+        else
+          @layout_root = remaining_child
+          remaining_child.parent = nil
+        end
+      end
+
+      true
+    end
+
+    def find_window_in_direction(direction)
+      return nil unless @active_window
+
+      predicate = DIRECTION_PREDICATES[direction]
+      return nil unless predicate
+
+      current_x = @active_window.x + (@active_window.width / 2)
+      current_y = @active_window.y + (@active_window.height / 2)
+
+      candidates = windows.reject { |w| w == @active_window }
+                          .select { |w| predicate.call(w, @active_window) }
+
+      candidates.min_by do |w|
+        wx = w.x + (w.width / 2)
+        wy = w.y + (w.height / 2)
+        Math.sqrt(((wx - current_x)**2) + ((wy - current_y)**2))
+      end
+    end
+
+    def create_window(buffer)
+      Window.new(
+        buffer,
+        x: 0,
+        y: 0,
+        width: @screen.width,
+        height: @screen.height,
+        color_scheme: @color_scheme
+      )
+    end
+
+    def render_separators(screen)
+      style = separator_style
+      separators.each do |sep|
+        case sep[:type]
+        when :horizontal
+          render_horizontal_separator(screen, sep, style)
+        when :vertical
+          render_vertical_separator(screen, sep, style)
+        end
+      end
+    end
+
+    def render_horizontal_separator(screen, sep, style)
+      line = "─" * sep[:length]
+      screen.put_with_style(sep[:y], sep[:x], line, style)
+    end
+
+    def render_vertical_separator(screen, sep, style)
+      sep[:length].times do |i|
+        screen.put_with_style(sep[:y] + i, sep[:x], "│", style)
+      end
+    end
+
+    def separator_style
+      return nil unless @color_scheme
+
+      @color_scheme[:separator]
+    end
+  end
+end