mui 0.1.0 → 0.2.0

data/lib/mui/key_handler/operators/change_operator.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Mui
+  module KeyHandler
+    module Operators
+      # NOTE: ChangeOperator inherits from DeleteOperator.
+      # This aligns with Vim semantics (change = "delete then enter INSERT mode")
+      # and keeps the code simple.
+      # However, if changes to DeleteOperator cause bugs in ChangeOperator,
+      # consider switching to a delegation pattern
+      # (inherit from BaseOperator and delegate to a DeleteOperator instance).
+
+      # Handles change operator (c) in Normal mode
+      class ChangeOperator < DeleteOperator
+        # Handle pending change motion
+        def handle_pending(char, pending_register: nil)
+          @pending_register = pending_register
+          case char
+          when "c"
+            change_line
+          when "w"
+            change_motion(:word_forward)
+          when "e"
+            change_motion(:word_end)
+          when "b"
+            change_motion(:word_backward)
+          when "0"
+            change_to_line_start
+          when "$"
+            change_to_line_end
+          when "g"
+            :pending_cg
+          when "G"
+            change_to_file_end
+          when "f"
+            :pending_cf
+          when "F"
+            :pending_cF
+          when "t"
+            :pending_ct
+          when "T"
+            :pending_cT
+          else
+            :cancel
+          end
+        end
+
+        # Handle cg (change to file start with gg)
+        def handle_to_file_start(char)
+          return :cancel unless char == "g"
+
+          if cursor_row.zero?
+            change_to_line_start_internal
+          else
+            change_to_file_start_internal
+          end
+          :insert_mode
+        end
+
+        # Handle cf/cF/ct/cT (change with find char)
+        def handle_find_char(char, motion_type)
+          motion_result = case motion_type
+                          when :cf
+                            Motion.find_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :cF
+                            Motion.find_char_backward(@buffer, cursor_row, cursor_col, char)
+                          when :ct
+                            Motion.till_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :cT
+                            Motion.till_char_backward(@buffer, cursor_row, cursor_col, char)
+                          end
+          return :cancel unless motion_result
+
+          execute_find_char_change(motion_result, motion_type)
+          :insert_mode
+        end
+
+        private
+
+        def change_line
+          text = @buffer.line(cursor_row)
+          @register.delete(text, linewise: true, name: @pending_register)
+          @buffer.lines[cursor_row] = +""
+          self.cursor_col = 0
+          :insert_mode
+        end
+
+        def change_motion(motion_type)
+          start_pos = { row: cursor_row, col: cursor_col }
+          # cw behaves like ce in Vim (changes to end of word, not to start of next word)
+          effective_motion = motion_type == :word_forward ? :word_end : motion_type
+          end_pos = calculate_motion_end(effective_motion)
+          return :cancel unless end_pos
+
+          inclusive = effective_motion == :word_end
+          text = extract_text(start_pos, end_pos, inclusive:)
+          @register.delete(text, linewise: false, name: @pending_register)
+          execute_delete(start_pos, end_pos, inclusive:, clamp: false)
+          :insert_mode
+        end
+
+        def change_to_line_start
+          return :insert_mode if cursor_col.zero?
+
+          text = @buffer.line(cursor_row)[0...cursor_col]
+          @register.delete(text, linewise: false, name: @pending_register)
+          @buffer.delete_range(cursor_row, 0, cursor_row, cursor_col - 1)
+          self.cursor_col = 0
+          :insert_mode
+        end
+
+        def change_to_line_end
+          line = @buffer.line(cursor_row)
+          return :insert_mode if line.empty?
+
+          text = line[cursor_col..]
+          @register.delete(text, linewise: false, name: @pending_register)
+          end_col = line.length - 1
+          @buffer.delete_range(cursor_row, cursor_col, cursor_row, end_col)
+          # Don't clamp cursor - keep it at original position for insert mode
+          :insert_mode
+        end
+
+        def change_to_file_end
+          last_row = @buffer.line_count - 1
+          if cursor_row == last_row
+            change_line
+          else
+            lines = (cursor_row..last_row).map { |r| @buffer.line(r) }
+            @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
+            (last_row - cursor_row + 1).times { @buffer.delete_line(cursor_row) }
+            @buffer.insert_line(cursor_row) if @buffer.line_count == cursor_row
+            self.cursor_row = [cursor_row, @buffer.line_count - 1].min
+            self.cursor_col = 0
+            :insert_mode
+          end
+        end
+
+        def change_to_line_start_internal
+          return if cursor_col.zero?
+
+          text = @buffer.line(cursor_row)[0...cursor_col]
+          @register.delete(text, linewise: false, name: @pending_register)
+          @buffer.delete_range(cursor_row, 0, cursor_row, cursor_col - 1)
+          self.cursor_col = 0
+        end
+
+        def change_to_file_start_internal
+          lines = (0..cursor_row).map { |r| @buffer.line(r) }
+          @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
+          cursor_row.times { @buffer.delete_line(0) }
+          @buffer.delete_range(0, 0, 0, cursor_col - 1) if cursor_col.positive?
+          self.cursor_row = 0
+          self.cursor_col = 0
+        end
+
+        def execute_find_char_change(motion_result, motion_type)
+          line = @buffer.line(cursor_row)
+          text = case motion_type
+                 when :cf, :ct
+                   line[cursor_col..motion_result[:col]]
+                 when :cF, :cT
+                   line[motion_result[:col]...cursor_col]
+                 end
+          @register.delete(text, linewise: false, name: @pending_register) if text
+
+          case motion_type
+          when :cf, :ct
+            @buffer.delete_range(cursor_row, cursor_col, cursor_row, motion_result[:col])
+          when :cF, :cT
+            @buffer.delete_range(cursor_row, motion_result[:col], cursor_row, cursor_col - 1)
+            self.cursor_col = motion_result[:col]
+          end
+          # Don't clamp cursor - keep it at original position for insert mode
+        end
+      end
+    end
+  end
+end

data/lib/mui/key_handler/operators/delete_operator.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Mui
+  module KeyHandler
+    module Operators
+      # Handles delete operator (d) in Normal mode
+      class DeleteOperator < BaseOperator
+        # Handle pending delete motion
+        def handle_pending(char, pending_register: nil)
+          @pending_register = pending_register
+          case char
+          when "d"
+            delete_line
+          when "w"
+            delete_motion(:word_forward)
+          when "e"
+            delete_motion(:word_end)
+          when "b"
+            delete_motion(:word_backward)
+          when "0"
+            delete_to_line_start
+          when "$"
+            delete_to_line_end
+          when "g"
+            :pending_dg
+          when "G"
+            delete_to_file_end
+          when "f"
+            :pending_df
+          when "F"
+            :pending_dF
+          when "t"
+            :pending_dt
+          when "T"
+            :pending_dT
+          else
+            :cancel
+          end
+        end
+
+        # Handle dg (delete to file start with gg)
+        def handle_to_file_start(char)
+          return :cancel unless char == "g"
+
+          if cursor_row.zero?
+            delete_to_line_start_internal
+          else
+            delete_to_file_start_internal
+          end
+          :done
+        end
+
+        # Handle df/dF/dt/dT (delete with find char)
+        def handle_find_char(char, motion_type)
+          motion_result = case motion_type
+                          when :df
+                            Motion.find_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :dF
+                            Motion.find_char_backward(@buffer, cursor_row, cursor_col, char)
+                          when :dt
+                            Motion.till_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :dT
+                            Motion.till_char_backward(@buffer, cursor_row, cursor_col, char)
+                          end
+          return :cancel unless motion_result
+
+          execute_find_char_delete(motion_result, motion_type)
+          :done
+        end
+
+        protected
+
+        def delete_line
+          text = @buffer.line(cursor_row)
+          @register.delete(text, linewise: true, name: @pending_register)
+          @buffer.delete_line(cursor_row)
+          self.cursor_row = [cursor_row, @buffer.line_count - 1].min
+          @window.clamp_cursor_to_line(@buffer)
+          :done
+        end
+
+        def delete_motion(motion_type)
+          start_pos = { row: cursor_row, col: cursor_col }
+          end_pos = calculate_motion_end(motion_type)
+          return :cancel unless end_pos
+
+          inclusive = motion_type == :word_end
+          text = extract_text(start_pos, end_pos, inclusive:)
+          @register.delete(text, linewise: false, name: @pending_register)
+          execute_delete(start_pos, end_pos, inclusive:)
+          :done
+        end
+
+        def delete_to_line_start
+          return :done if cursor_col.zero?
+
+          text = @buffer.line(cursor_row)[0...cursor_col]
+          @register.delete(text, linewise: false, name: @pending_register)
+          @buffer.delete_range(cursor_row, 0, cursor_row, cursor_col - 1)
+          self.cursor_col = 0
+          :done
+        end
+
+        def delete_to_line_end
+          line = @buffer.line(cursor_row)
+          return :done if line.empty?
+
+          text = line[cursor_col..]
+          @register.delete(text, linewise: false, name: @pending_register)
+          end_col = line.length - 1
+          @buffer.delete_range(cursor_row, cursor_col, cursor_row, end_col)
+          @window.clamp_cursor_to_line(@buffer)
+          :done
+        end
+
+        def delete_to_file_end
+          last_row = @buffer.line_count - 1
+          if cursor_row == last_row
+            delete_line
+          else
+            lines = (cursor_row..last_row).map { |r| @buffer.line(r) }
+            @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
+            @undo_manager&.begin_group
+            (last_row - cursor_row + 1).times { @buffer.delete_line(cursor_row) }
+            @undo_manager&.end_group
+            self.cursor_row = [cursor_row, @buffer.line_count - 1].min
+            @window.clamp_cursor_to_line(@buffer)
+            :done
+          end
+        end
+
+        private
+
+        def delete_to_line_start_internal
+          return if cursor_col.zero?
+
+          text = @buffer.line(cursor_row)[0...cursor_col]
+          @register.delete(text, linewise: false, name: @pending_register)
+          @buffer.delete_range(cursor_row, 0, cursor_row, cursor_col - 1)
+          self.cursor_col = 0
+        end
+
+        def delete_to_file_start_internal
+          lines = (0..cursor_row).map { |r| @buffer.line(r) }
+          @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
+          @undo_manager&.begin_group
+          cursor_row.times { @buffer.delete_line(0) }
+          @buffer.delete_range(0, 0, 0, cursor_col - 1) if cursor_col.positive?
+          @undo_manager&.end_group
+          self.cursor_row = 0
+          self.cursor_col = 0
+        end
+
+        def execute_find_char_delete(motion_result, motion_type)
+          line = @buffer.line(cursor_row)
+          text = case motion_type
+                 when :df, :dt
+                   line[cursor_col..motion_result[:col]]
+                 when :dF, :dT
+                   line[motion_result[:col]...cursor_col]
+                 end
+          @register.delete(text, linewise: false, name: @pending_register) if text
+
+          case motion_type
+          when :df, :dt
+            @buffer.delete_range(cursor_row, cursor_col, cursor_row, motion_result[:col])
+          when :dF, :dT
+            @buffer.delete_range(cursor_row, motion_result[:col], cursor_row, cursor_col - 1)
+            self.cursor_col = motion_result[:col]
+          end
+          @window.clamp_cursor_to_line(@buffer)
+        end
+      end
+    end
+  end
+end

data/lib/mui/key_handler/operators/paste_operator.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Mui
+  module KeyHandler
+    module Operators
+      # Handles paste operator (p/P) in Normal mode
+      class PasteOperator < BaseOperator
+        # Paste after cursor (p)
+        def paste_after(pending_register: nil)
+          return :done if @register.empty?(name: pending_register)
+
+          if @register.linewise?(name: pending_register)
+            paste_line_after(name: pending_register)
+          else
+            paste_char_after(name: pending_register)
+          end
+          :done
+        end
+
+        # Paste before cursor (P)
+        def paste_before(pending_register: nil)
+          return :done if @register.empty?(name: pending_register)
+
+          if @register.linewise?(name: pending_register)
+            paste_line_before(name: pending_register)
+          else
+            paste_char_before(name: pending_register)
+          end
+          :done
+        end
+
+        # Not used for paste, but required by base class interface
+        def handle_pending(_char, pending_register: nil) # rubocop:disable Lint/UnusedMethodArgument
+          :cancel
+        end
+
+        private
+
+        def paste_line_after(name: nil)
+          text = @register.get(name:)
+          lines = text.split("\n", -1)
+          lines.reverse_each do |line|
+            @buffer.insert_line(cursor_row + 1, line)
+          end
+          self.cursor_row = cursor_row + 1
+          self.cursor_col = 0
+        end
+
+        def paste_line_before(name: nil)
+          text = @register.get(name:)
+          lines = text.split("\n", -1)
+          lines.reverse_each do |line|
+            @buffer.insert_line(cursor_row, line)
+          end
+          self.cursor_col = 0
+        end
+
+        def paste_char_after(name: nil)
+          text = @register.get(name:)
+          line = @buffer.line(cursor_row)
+          insert_col = line.empty? ? 0 : cursor_col + 1
+
+          if text.include?("\n")
+            paste_multiline_char(text, line, insert_col)
+          else
+            @buffer.lines[cursor_row] = line[0...insert_col].to_s + text + line[insert_col..].to_s
+            self.cursor_col = insert_col + text.length - 1
+            @window.clamp_cursor_to_line(@buffer)
+          end
+        end
+
+        def paste_char_before(name: nil)
+          text = @register.get(name:)
+          line = @buffer.line(cursor_row)
+
+          if text.include?("\n")
+            paste_multiline_char(text, line, cursor_col)
+          else
+            @buffer.lines[cursor_row] = line[0...cursor_col].to_s + text + line[cursor_col..].to_s
+            self.cursor_col = cursor_col + text.length - 1
+            @window.clamp_cursor_to_line(@buffer)
+          end
+        end
+
+        def paste_multiline_char(text, line, insert_col)
+          lines = text.split("\n", -1)
+          before = line[0...insert_col].to_s
+          after = line[insert_col..].to_s
+
+          # First line: before + first part of pasted text
+          @buffer.lines[cursor_row] = before + lines.first
+
+          # Middle lines: insert as new lines
+          lines[1...-1].each_with_index do |pasted_line, idx|
+            @buffer.insert_line(cursor_row + 1 + idx, pasted_line)
+          end
+
+          # Last line: last part of pasted text + after
+          if lines.length > 1
+            last_line_row = cursor_row + lines.length - 1
+            @buffer.insert_line(last_line_row, lines.last + after)
+          end
+
+          # Position cursor at the end of pasted text (before 'after' part)
+          self.cursor_row = cursor_row + lines.length - 1
+          self.cursor_col = lines.last.length - 1
+          self.cursor_col = 0 if cursor_col.negative?
+          @window.clamp_cursor_to_line(@buffer)
+        end
+      end
+    end
+  end
+end

data/lib/mui/key_handler/operators/yank_operator.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Mui
+  module KeyHandler
+    module Operators
+      # Handles yank operator (y) in Normal mode
+      # Unlike delete/change, yank does not modify the buffer
+      class YankOperator < BaseOperator
+        # Handle pending yank motion
+        def handle_pending(char, pending_register: nil)
+          @pending_register = pending_register
+          case char
+          when "y"
+            yank_line
+          when "w"
+            yank_motion(:word_forward)
+          when "e"
+            yank_motion(:word_end)
+          when "b"
+            yank_motion(:word_backward)
+          when "0"
+            yank_to_line_start
+          when "$"
+            yank_to_line_end
+          when "g"
+            :pending_yg
+          when "G"
+            yank_to_file_end
+          when "f"
+            :pending_yf
+          when "F"
+            :pending_yF
+          when "t"
+            :pending_yt
+          when "T"
+            :pending_yT
+          else
+            :cancel
+          end
+        end
+
+        # Handle yg (yank to file start with gg)
+        def handle_to_file_start(char)
+          return :cancel unless char == "g"
+
+          lines = (0..cursor_row).map { |r| @buffer.line(r) }
+          text = lines.join("\n")
+          @register.yank(text, linewise: true, name: @pending_register)
+          :done
+        end
+
+        # Handle yf/yF/yt/yT (yank with find char)
+        def handle_find_char(char, motion_type)
+          motion_result = case motion_type
+                          when :yf
+                            Motion.find_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :yF
+                            Motion.find_char_backward(@buffer, cursor_row, cursor_col, char)
+                          when :yt
+                            Motion.till_char_forward(@buffer, cursor_row, cursor_col, char)
+                          when :yT
+                            Motion.till_char_backward(@buffer, cursor_row, cursor_col, char)
+                          end
+          return :cancel unless motion_result
+
+          execute_find_char_yank(motion_result, motion_type)
+          :done
+        end
+
+        private
+
+        def yank_line
+          text = @buffer.line(cursor_row)
+          @register.yank(text, linewise: true, name: @pending_register)
+          :done
+        end
+
+        def yank_motion(motion_type)
+          start_pos = { row: cursor_row, col: cursor_col }
+          effective_motion = motion_type == :word_forward ? :word_end : motion_type
+          end_pos = calculate_motion_end(effective_motion)
+          return :cancel unless end_pos
+
+          inclusive = effective_motion == :word_end
+          text = extract_text(start_pos, end_pos, inclusive:)
+          @register.yank(text, linewise: false, name: @pending_register)
+          :done
+        end
+
+        def yank_to_line_start
+          return :done if cursor_col.zero?
+
+          text = @buffer.line(cursor_row)[0...cursor_col]
+          @register.yank(text, linewise: false, name: @pending_register)
+          :done
+        end
+
+        def yank_to_line_end
+          line = @buffer.line(cursor_row)
+          return :done if line.empty?
+
+          text = line[cursor_col..]
+          @register.yank(text, linewise: false, name: @pending_register)
+          :done
+        end
+
+        def yank_to_file_end
+          lines = (cursor_row...@buffer.line_count).map { |r| @buffer.line(r) }
+          text = lines.join("\n")
+          @register.yank(text, linewise: true, name: @pending_register)
+          :done
+        end
+
+        def execute_find_char_yank(motion_result, motion_type)
+          line = @buffer.line(cursor_row)
+          text = case motion_type
+                 when :yf, :yt
+                   line[cursor_col..motion_result[:col]]
+                 when :yF, :yT
+                   line[motion_result[:col]...cursor_col]
+                 end
+          @register.yank(text, linewise: false, name: @pending_register)
+        end
+      end
+    end
+  end
+end