ruvim 0.1.0

data/test/app_startup_test.rb

@@ -0,0 +1,199 @@
+require_relative "test_helper"
+require "tempfile"
+require "stringio"
+
+class AppStartupTest < Minitest::Test
+  def test_startup_ex_command_runs_after_boot
+    app = RuVim::App.new(clean: true, startup_actions: [{ type: :ex, value: "set number" }])
+    editor = app.instance_variable_get(:@editor)
+
+    assert_equal true, editor.effective_option("number")
+  end
+
+  def test_startup_line_moves_cursor
+    Tempfile.create(["ruvim-startup", ".txt"]) do |f|
+      f.write("a\nb\nc\nd\n")
+      f.flush
+
+      app = RuVim::App.new(path: f.path, clean: true, startup_actions: [{ type: :line, value: 3 }])
+      editor = app.instance_variable_get(:@editor)
+
+      assert_equal 2, editor.current_window.cursor_y
+      assert_equal "c", editor.current_buffer.line_at(editor.current_window.cursor_y)
+    end
+  end
+
+  def test_startup_line_end_moves_to_last_line
+    Tempfile.create(["ruvim-startup", ".txt"]) do |f|
+      f.write("a\nb\nc\n")
+      f.flush
+
+      app = RuVim::App.new(path: f.path, clean: true, startup_actions: [{ type: :line_end }])
+      editor = app.instance_variable_get(:@editor)
+
+      assert_equal 2, editor.current_window.cursor_y
+      assert_equal "c", editor.current_buffer.line_at(editor.current_window.cursor_y)
+    end
+  end
+
+  def test_startup_readonly_marks_opened_buffer_readonly
+    Tempfile.create(["ruvim-startup", ".txt"]) do |f|
+      f.write("hello\n")
+      f.flush
+
+      app = RuVim::App.new(path: f.path, clean: true, readonly: true)
+      editor = app.instance_variable_get(:@editor)
+
+      assert_equal true, editor.current_buffer.readonly?
+    end
+  end
+
+  def test_startup_diff_mode_placeholder_emits_message
+    app = RuVim::App.new(clean: true, diff_mode: true)
+    editor = app.instance_variable_get(:@editor)
+
+    assert_match(/diff mode .*not implemented/i, editor.message)
+  end
+
+  def test_startup_quickfix_placeholder_emits_message
+    app = RuVim::App.new(clean: true, quickfix_errorfile: "errors.log")
+    editor = app.instance_variable_get(:@editor)
+
+    assert_match(/quickfix startup .*errors\.log.*not implemented/i, editor.message)
+  end
+
+  def test_startup_session_placeholder_emits_message
+    app = RuVim::App.new(clean: true, session_file: "Session.ruvim")
+    editor = app.instance_variable_get(:@editor)
+
+    assert_match(/session startup .*Session\.ruvim.*not implemented/i, editor.message)
+  end
+
+  def test_startup_nomodifiable_marks_opened_buffer_unmodifiable_and_readonly
+    Tempfile.create(["ruvim-startup", ".txt"]) do |f|
+      f.write("hello\n")
+      f.flush
+
+      app = RuVim::App.new(path: f.path, clean: true, nomodifiable: true)
+      editor = app.instance_variable_get(:@editor)
+
+      assert_equal false, editor.current_buffer.modifiable?
+      assert_equal true, editor.current_buffer.readonly?
+    end
+  end
+
+  def test_startup_restricted_mode_sets_editor_flag
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+
+    assert_equal true, editor.restricted_mode?
+  end
+
+  def test_startup_horizontal_split_opens_multiple_files
+    Tempfile.create(["ruvim-a", ".txt"]) do |a|
+      Tempfile.create(["ruvim-b", ".txt"]) do |b|
+        a.write("a\n"); a.flush
+        b.write("b\n"); b.flush
+
+        app = RuVim::App.new(paths: [a.path, b.path], clean: true, startup_open_layout: :horizontal)
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal :horizontal, editor.window_layout
+        assert_equal 2, editor.window_order.length
+        names = editor.window_order.map { |id| editor.buffers[editor.windows[id].buffer_id].path }
+        assert_includes names, a.path
+        assert_includes names, b.path
+      end
+    end
+  end
+
+  def test_startup_tab_layout_opens_multiple_tabs
+    Tempfile.create(["ruvim-a", ".txt"]) do |a|
+      Tempfile.create(["ruvim-b", ".txt"]) do |b|
+        a.write("a\n"); a.flush
+        b.write("b\n"); b.flush
+
+        app = RuVim::App.new(paths: [a.path, b.path], clean: true, startup_open_layout: :tab)
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal 2, editor.tabpage_count
+      end
+    end
+  end
+
+  def test_restricted_mode_disables_ex_ruby
+    app = RuVim::App.new(clean: true, restricted: true)
+    editor = app.instance_variable_get(:@editor)
+    dispatcher = app.instance_variable_get(:@dispatcher)
+
+    dispatcher.dispatch_ex(editor, "ruby 1+1")
+
+    assert_match(/Restricted mode/, editor.message)
+  end
+
+  def test_verbose_logs_startup_and_startup_ex_actions
+    log = StringIO.new
+    app = RuVim::App.new(
+      clean: true,
+      verbose_level: 2,
+      verbose_io: log,
+      startup_actions: [{ type: :ex, value: "set number" }]
+    )
+    editor = app.instance_variable_get(:@editor)
+    assert_equal true, editor.effective_option("number")
+
+    text = log.string
+    assert_match(/startup: load_user_config/, text)
+    assert_match(/startup: run_startup_actions/, text)
+    assert_match(/startup ex: set number/, text)
+  end
+
+  def test_pre_config_actions_run_before_user_config_and_startup_actions
+    Tempfile.create(["ruvim-config", ".rb"]) do |cfg|
+      cfg.write("::ENV['RUVIM_PRECONFIG_ORDER_TEST'] = 'config_loaded'\n")
+      cfg.flush
+
+      begin
+        ENV.delete("RUVIM_PRECONFIG_ORDER_TEST")
+        log = StringIO.new
+        app = RuVim::App.new(
+          config_path: cfg.path,
+          pre_config_actions: [{ type: :ex, value: "set number" }],
+          startup_actions: [{ type: :ex, value: "set relativenumber" }],
+          verbose_level: 2,
+          verbose_io: log
+        )
+        editor = app.instance_variable_get(:@editor)
+
+        assert_equal true, editor.effective_option("number")
+        assert_equal true, editor.effective_option("relativenumber")
+        assert_equal "config_loaded", ENV["RUVIM_PRECONFIG_ORDER_TEST"]
+
+        text = log.string
+        assert_match(/startup: run_pre_config_actions count=1/, text)
+        assert_match(/pre-config ex: set number/, text)
+        assert_match(/startup: load_user_config/, text)
+        assert_match(/startup ex: set relativenumber/, text)
+        assert_operator text.index("startup: run_pre_config_actions"), :<, text.index("startup: load_user_config")
+        assert_operator text.index("startup: load_user_config"), :<, text.index("startup: run_startup_actions")
+      ensure
+        ENV.delete("RUVIM_PRECONFIG_ORDER_TEST")
+      end
+    end
+  end
+
+  def test_startuptime_writes_startup_phase_log
+    Tempfile.create(["ruvim-startuptime", ".log"]) do |f|
+      path = f.path
+      f.close
+
+      RuVim::App.new(clean: true, startup_time_path: path)
+
+      text = File.read(path)
+      assert_match(/init\.start/, text)
+      assert_match(/pre_config_actions\.done/, text)
+      assert_match(/buffers\.opened/, text)
+      assert_match(/startup_actions\.done/, text)
+    end
+  end
+end

data/test/app_text_object_test.rb

@@ -0,0 +1,54 @@
+require_relative "test_helper"
+
+class AppTextObjectTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+    @buffer = @editor.current_buffer
+    @win = @editor.current_window
+  end
+
+  def press(*keys)
+    keys.each { |k| @app.send(:handle_normal_key, k) }
+  end
+
+  def test_delete_inside_square_brackets
+    @buffer.replace_all_lines!(["x[abc]y"])
+    @win.cursor_x = 2
+
+    press("d", "i", "]")
+
+    assert_equal "x[]y", @buffer.line_at(0)
+  end
+
+  def test_delete_inside_backticks
+    @buffer.replace_all_lines!(["a`bc`d"])
+    @win.cursor_x = 2
+
+    press("d", "i", "`")
+
+    assert_equal "a``d", @buffer.line_at(0)
+  end
+
+  def test_yank_inner_paragraph
+    @buffer.replace_all_lines!(["foo", "bar", "", "baz"])
+    @win.cursor_y = 1
+    @win.cursor_x = 1
+
+    press("y", "i", "p")
+
+    assert_equal({ text: "foo\nbar", type: :charwise }, @editor.get_register("\""))
+    assert_equal({ text: "foo\nbar", type: :charwise }, @editor.get_register("0"))
+  end
+
+  def test_delete_around_paragraph_includes_separator_blank_line
+    @buffer.replace_all_lines!(["foo", "bar", "", "baz"])
+    @win.cursor_y = 0
+    @win.cursor_x = 0
+
+    press("d", "a", "p")
+
+    assert_equal ["baz"], @buffer.lines
+  end
+end

data/test/app_unicode_behavior_test.rb

@@ -0,0 +1,66 @@
+require_relative "test_helper"
+
+class AppUnicodeBehaviorTest < Minitest::Test
+  def setup
+    @app = RuVim::App.new(clean: true)
+    @editor = @app.instance_variable_get(:@editor)
+    @editor.materialize_intro_buffer!
+    @buffer = @editor.current_buffer
+    @win = @editor.current_window
+  end
+
+  def press_normal(*keys)
+    keys.each { |k| @app.send(:handle_normal_key, k) }
+  end
+
+  def press(*keys)
+    keys.each { |k| @app.send(:handle_key, k) }
+  end
+
+  def test_word_motions_on_japanese_text_do_not_break_character_boundaries
+    @buffer.replace_all_lines!(["foo 日本語 編集"])
+    @win.cursor_y = 0
+    @win.cursor_x = 0
+
+    press_normal("w")
+    assert_equal "日", @buffer.line_at(0)[@win.cursor_x]
+
+    press_normal("e")
+    assert_equal "語", @buffer.line_at(0)[@win.cursor_x]
+
+    press_normal("w")
+    assert_equal "編", @buffer.line_at(0)[@win.cursor_x]
+
+    press_normal("b")
+    assert_equal "日", @buffer.line_at(0)[@win.cursor_x]
+  end
+
+  def test_paste_charwise_japanese_text_keeps_valid_cursor_position
+    @buffer.replace_all_lines!(["abc"])
+    @editor.set_register("\"", text: "日本", type: :charwise)
+    @win.cursor_y = 0
+    @win.cursor_x = 0
+
+    press_normal("p")
+    assert_equal "a日本bc", @buffer.line_at(0)
+    assert_equal true, @buffer.line_at(0).valid_encoding?
+    assert_equal "本", @buffer.line_at(0)[@win.cursor_x]
+
+    press_normal("P")
+    assert_equal "a日日本本bc", @buffer.line_at(0)
+    assert_equal true, @buffer.line_at(0).valid_encoding?
+    assert_equal "本", @buffer.line_at(0)[@win.cursor_x]
+  end
+
+  def test_visual_yank_on_japanese_text_is_inclusive_and_valid_utf8
+    @buffer.replace_all_lines!(["A日本語B"])
+    @win.cursor_x = 1 # 日
+
+    press("v", "l", "y")
+
+    reg = @editor.get_register("\"")
+    assert_equal({ text: "日本", type: :charwise }, reg)
+    assert_equal true, reg[:text].valid_encoding?
+    assert_equal :normal, @editor.mode
+  end
+end

data/test/buffer_test.rb

@@ -0,0 +1,72 @@
+require_relative "test_helper"
+
+class BufferTest < Minitest::Test
+  def test_insert_and_undo_redo_group
+    b = RuVim::Buffer.new(id: 1)
+    b.begin_change_group
+    b.insert_char(0, 0, "a")
+    b.insert_char(0, 1, "b")
+    b.end_change_group
+
+    assert_equal ["ab"], b.lines
+    assert b.undo!
+    assert_equal [""], b.lines
+    assert b.redo!
+    assert_equal ["ab"], b.lines
+  end
+
+  def test_delete_span_across_lines
+    b = RuVim::Buffer.new(id: 1, lines: ["abc", "def", "ghi"])
+    deleted = b.span_text(0, 1, 2, 1)
+    assert_equal "bc\ndef\ng", deleted
+
+    b.delete_span(0, 1, 2, 1)
+    assert_equal ["ahi"], b.lines
+  end
+
+  def test_reload_from_file_clears_modified_and_history
+    path = "/tmp/ruvim_buffer_reload_test.txt"
+    File.write(path, "one\n")
+    b = RuVim::Buffer.from_file(id: 1, path: path)
+    b.insert_char(0, 0, "X")
+    assert b.modified?
+    assert b.can_undo?
+
+    b.reload_from_file!
+    assert_equal ["one"], b.lines
+    refute b.modified?
+    refute b.can_undo?
+  end
+
+  def test_utf8_file_is_loaded_as_utf8_text_not_binary_bytes
+    path = "/tmp/ruvim_utf8_test.txt"
+    File.binwrite(path, "bar 日本語 編集\n".encode("UTF-8"))
+
+    b = RuVim::Buffer.from_file(id: 1, path: path)
+    assert_equal Encoding::UTF_8, b.line_at(0).encoding
+    assert_equal "bar 日本語 編集", b.line_at(0)
+    assert_equal 10, b.line_length(0)
+  end
+
+  def test_invalid_bytes_are_decoded_to_valid_utf8_with_replacement
+    path = "/tmp/ruvim_invalid_bytes_test.txt"
+    File.binwrite(path, "A\xFFB\n".b)
+
+    b = RuVim::Buffer.from_file(id: 1, path: path)
+    line = b.line_at(0)
+    assert_equal Encoding::UTF_8, line.encoding
+    assert_equal true, line.valid_encoding?
+    assert_match(/A.*B/, line)
+  end
+
+  def test_write_to_saves_utf8_text
+    path = "/tmp/ruvim_write_utf8_test.txt"
+    b = RuVim::Buffer.new(id: 1, lines: ["日本語", "abc"])
+    b.write_to(path)
+
+    data = File.binread(path)
+    text = data.force_encoding(Encoding::UTF_8)
+    assert_equal true, text.valid_encoding?
+    assert_equal "日本語\nabc", text
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,165 @@
+require_relative "test_helper"
+require "stringio"
+require "tempfile"
+
+class CLITest < Minitest::Test
+  def test_parse_clean_and_u_none
+    opts = RuVim::CLI.parse(["--clean", "-u", "NONE"])
+
+    assert_equal true, opts.clean
+    assert_equal true, opts.skip_user_config
+    assert_nil opts.config_path
+  end
+
+  def test_parse_startup_actions_preserves_order
+    opts = RuVim::CLI.parse(["+10", "-c", "set number", "+", "file.txt"])
+
+    assert_equal ["file.txt"], opts.files
+    assert_equal [
+      { type: :line, value: 10 },
+      { type: :ex, value: "set number" },
+      { type: :line_end }
+    ], opts.startup_actions
+  end
+
+  def test_parse_pre_config_cmd_option
+    opts = RuVim::CLI.parse(["--cmd", "set number", "--cmd=set relativenumber", "file.txt"])
+
+    assert_equal ["file.txt"], opts.files
+    assert_equal [
+      { type: :ex, value: "set number" },
+      { type: :ex, value: "set relativenumber" }
+    ], opts.pre_config_actions
+    assert_equal [], opts.startup_actions
+  end
+
+  def test_parse_custom_config_path
+    opts = RuVim::CLI.parse(["-u", "/tmp/ruvimrc.rb"])
+
+    assert_equal false, opts.skip_user_config
+    assert_equal "/tmp/ruvimrc.rb", opts.config_path
+  end
+
+  def test_parse_readonly_option
+    opts = RuVim::CLI.parse(["-R", "file.txt"])
+
+    assert_equal true, opts.readonly
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_diff_mode_option
+    opts = RuVim::CLI.parse(["-d", "file.txt"])
+
+    assert_equal true, opts.diff_mode
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_quickfix_option
+    opts = RuVim::CLI.parse(["-q", "errors.log", "file.txt"])
+
+    assert_equal "errors.log", opts.quickfix_errorfile
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_session_option_with_and_without_argument
+    opts1 = RuVim::CLI.parse(["-S", "Session.ruvim", "file.txt"])
+    assert_equal "Session.ruvim", opts1.session_file
+    assert_equal ["file.txt"], opts1.files
+
+    opts2 = RuVim::CLI.parse(["-S"])
+    assert_equal "Session.vim", opts2.session_file
+  end
+
+  def test_parse_nomodifiable_option
+    opts = RuVim::CLI.parse(["-M", "file.txt"])
+
+    assert_equal true, opts.nomodifiable
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_restricted_option
+    opts = RuVim::CLI.parse(["-Z", "file.txt"])
+
+    assert_equal true, opts.restricted_mode
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_verbose_options
+    v1 = RuVim::CLI.parse(["-V", "file.txt"])
+    assert_equal 1, v1.verbose_level
+
+    v2 = RuVim::CLI.parse(["-V2", "file.txt"])
+    assert_equal 2, v2.verbose_level
+
+    v3 = RuVim::CLI.parse(["--verbose=3", "file.txt"])
+    assert_equal 3, v3.verbose_level
+  end
+
+  def test_parse_startuptime_option
+    opts = RuVim::CLI.parse(["--startuptime", "/tmp/ruvim-startup.log", "file.txt"])
+
+    assert_equal "/tmp/ruvim-startup.log", opts.startup_time_path
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_n_option_as_accepted_no_op
+    opts = RuVim::CLI.parse(["-n", "file.txt"])
+
+    assert_equal true, opts.no_swap
+    assert_equal ["file.txt"], opts.files
+  end
+
+  def test_parse_split_and_tab_layout_options
+    o = RuVim::CLI.parse(["-o", "a", "b"])
+    assert_equal :horizontal, o.startup_open_layout
+    assert_nil o.startup_open_count
+
+    ov = RuVim::CLI.parse(["-O3", "a", "b"])
+    assert_equal :vertical, ov.startup_open_layout
+    assert_equal 3, ov.startup_open_count
+
+    p = RuVim::CLI.parse(["-p2", "a", "b"])
+    assert_equal :tab, p.startup_open_layout
+    assert_equal 2, p.startup_open_count
+  end
+
+  def test_help_and_version_return_without_starting_ui
+    out = StringIO.new
+    err = StringIO.new
+
+    code = RuVim::CLI.run(["--version"], stdout: out, stderr: err, stdin: StringIO.new)
+    assert_equal 0, code
+    assert_match(/RuVim /, out.string)
+    assert_equal "", err.string
+
+    out = StringIO.new
+    err = StringIO.new
+    code = RuVim::CLI.run(["--help"], stdout: out, stderr: err, stdin: StringIO.new)
+    assert_equal 0, code
+    assert_match(/Usage: ruvim/, out.string)
+    assert_match(/-R\s+Open file readonly/, out.string)
+    assert_match(/-d\s+Diff mode requested/, out.string)
+    assert_match(/-q \{errorfile\}\s+Quickfix startup placeholder/, out.string)
+    assert_match(/-S \[session\]\s+Session startup placeholder/, out.string)
+    assert_match(/-M\s+Open file unmodifiable/, out.string)
+    assert_match(/-Z\s+Restricted mode/, out.string)
+    assert_match(/-V\[N\], --verbose/, out.string)
+    assert_match(/--startuptime FILE/, out.string)
+    assert_match(/--cmd \{cmd\}/, out.string)
+    assert_match(/-n\s+No-op/, out.string)
+    assert_match(/-o\[N\]/, out.string)
+    assert_match(/-O\[N\]/, out.string)
+    assert_match(/-p\[N\]/, out.string)
+    assert_equal "", err.string
+  end
+
+  def test_run_returns_error_for_missing_config_file
+    out = StringIO.new
+    err = StringIO.new
+
+    code = RuVim::CLI.run(["-u", "/tmp/ruvim/no-such-config.rb"], stdout: out, stderr: err, stdin: StringIO.new)
+
+    assert_equal 2, code
+    assert_match(/config file not found/, err.string)
+  end
+end

data/test/config_dsl_test.rb

@@ -0,0 +1,78 @@
+require_relative "test_helper"
+
+class ConfigDSLTest < Minitest::Test
+  FakeCommandSpec = Struct.new(:id, :call, :desc, :source, keyword_init: true)
+
+  class FakeCommandRegistry
+    attr_reader :specs
+
+    def initialize
+      @specs = {}
+    end
+
+    def register(id, call:, desc:, source:)
+      @specs[id.to_s] = FakeCommandSpec.new(id: id.to_s, call:, desc:, source:)
+    end
+
+    def fetch(id)
+      @specs.fetch(id.to_s)
+    end
+  end
+
+  class FakeExRegistry
+    def registered?(_name)
+      false
+    end
+
+    def unregister(_name)
+      nil
+    end
+
+    def register(*)
+      nil
+    end
+  end
+
+  def setup
+    @command_registry = FakeCommandRegistry.new
+    @ex_registry = FakeExRegistry.new
+    @keymaps = RuVim::KeymapManager.new
+    @dsl = RuVim::ConfigDSL.new(
+      command_registry: @command_registry,
+      ex_registry: @ex_registry,
+      keymaps: @keymaps,
+      command_host: RuVim::GlobalCommands.instance
+    )
+  end
+
+  def test_nmap_block_registers_inline_command_and_binds_key
+    @dsl.nmap("K", desc: "Show name") { |ctx, **| ctx.editor.echo(ctx.buffer.display_name) }
+
+    match = @keymaps.resolve(:normal, ["K"])
+    assert_equal :match, match.status
+    refute_nil match.invocation
+    assert match.invocation.id.start_with?("user.keymap.normal.")
+
+    spec = @command_registry.fetch(match.invocation.id)
+    assert_equal :user, spec.source
+    assert_equal "Show name", spec.desc
+    assert_respond_to spec.call, :call
+  end
+
+  def test_imap_block_registers_insert_mode_binding
+    @dsl.imap("Q", desc: "Insert helper") { |_ctx, **| }
+
+    match = @keymaps.resolve(:insert, ["Q"])
+    assert_equal :match, match.status
+    assert match.invocation.id.start_with?("user.keymap.insert.")
+  end
+
+  def test_map_global_block_binds_fallback_layer_when_mode_nil
+    @dsl.map_global("Z", mode: nil, desc: "Global fallback") { |_ctx, **| }
+
+    editor = fresh_editor
+    match = @keymaps.resolve_with_context(:normal, ["Z"], editor: editor)
+    assert_equal :match, match.status
+    assert match.invocation.id.start_with?("user.keymap.global.")
+  end
+end