mui 0.1.0 → 0.3.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.3.0"
 end

data/lib/mui/window.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Mui
+  class Window
+    attr_accessor :x, :y, :width, :height, :cursor_row, :cursor_col, :scroll_row
+    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
+      @color_scheme = color_scheme
+      @wrap_cache = WrapCache.new
+      @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
+      @wrap_cache.clear
+      @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
+      # Calculate screen row of cursor considering line wrapping
+      cursor_screen_row = screen_rows_from_scroll_to_cursor
+
+      # Scroll up if cursor is above visible area
+      @scroll_row -= 1 while @cursor_row < @scroll_row
+
+      # Scroll down if cursor is below visible area
+      while cursor_screen_row >= visible_height
+        @scroll_row += 1
+        cursor_screen_row = screen_rows_from_scroll_to_cursor
+      end
+    end
+
+    def render(screen, selection: nil, search_state: nil)
+      options = build_render_options(selection, search_state)
+      screen_row = 0
+      logical_row = @scroll_row
+
+      while screen_row < visible_height && logical_row < @buffer.line_count
+        line = @buffer.line(logical_row)
+        wrapped_lines = WrapHelper.wrap_line(line, visible_width, cache: @wrap_cache)
+
+        wrapped_lines.each do |wrap_info|
+          break if screen_row >= visible_height
+
+          render_wrapped_segment(screen, logical_row, wrap_info, screen_row, options)
+          screen_row += 1
+        end
+
+        logical_row += 1
+      end
+
+      # Clear remaining lines
+      while screen_row < visible_height
+        clear_line(screen, screen_row)
+        screen_row += 1
+      end
+
+      @status_line_renderer.render(screen, @y + visible_height)
+    end
+
+    def render_wrapped_segment(screen, logical_row, wrap_info, screen_row, options)
+      wrap_options = options.merge(logical_row:)
+      @line_renderer.render_wrapped_line(screen, @y + screen_row, @x, wrap_info, wrap_options)
+
+      # Fill remaining width with spaces if line is shorter
+      text_width = UnicodeWidth.string_width(wrap_info[:text])
+      return unless text_width < visible_width
+
+      remaining_width = visible_width - text_width
+      fill_text = " " * remaining_width
+      if @color_scheme && @color_scheme[:normal]
+        screen.put_with_style(@y + screen_row, @x + text_width, fill_text, @color_scheme[:normal])
+      else
+        screen.put(@y + screen_row, @x + text_width, fill_text)
+      end
+    end
+
+    def screen_cursor_x
+      line = @buffer.line(@cursor_row) || ""
+      _, screen_col = WrapHelper.logical_to_screen(line, @cursor_col, visible_width, cache: @wrap_cache)
+      @x + screen_col
+    end
+
+    def screen_cursor_y
+      @y + screen_rows_from_scroll_to_cursor
+    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 clear_line(screen, screen_row)
+      empty_line = " " * visible_width
+      if @color_scheme && @color_scheme[:normal]
+        screen.put_with_style(@y + screen_row, @x, empty_line, @color_scheme[:normal])
+      else
+        screen.put(@y + screen_row, @x, empty_line)
+      end
+    end
+
+    # Calculates screen rows from scroll_row to cursor position
+    def screen_rows_from_scroll_to_cursor
+      screen_rows = 0
+
+      # Add screen lines for rows between scroll_row and cursor_row
+      (@scroll_row...@cursor_row).each do |row|
+        line = @buffer.line(row) || ""
+        screen_rows += WrapHelper.screen_line_count(line, visible_width, cache: @wrap_cache)
+      end
+
+      # Add the row offset within the cursor's line
+      cursor_line = @buffer.line(@cursor_row) || ""
+      row_offset, = WrapHelper.logical_to_screen(cursor_line, @cursor_col, visible_width, cache: @wrap_cache)
+      screen_rows + row_offset
+    end
+
+    # Clear wrap cache when window dimensions change
+    def resize(new_width, new_height)
+      @width = new_width
+      @height = new_height
+      @wrap_cache.clear
+    end
+
+    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 build_render_options(selection, search_state)
+      { selection:, search_state:, buffer: @buffer }
+    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