llmx/codex-cli/tests/text-buffer.test.ts

import TextBuffer from "../src/text-buffer";
import { describe, it, expect } from "vitest";

describe("TextBuffer – basic editing parity with Rust suite", () => {
  /* ------------------------------------------------------------------ */
  /*  insert_char                                                        */
  /* ------------------------------------------------------------------ */
  it("insert_char / printable (single line)", () => {
    // (col, char, expectedLine)
    const cases: Array<[number, string, string]> = [
      [0, "x", "xab"],
      [1, "x", "axb"],
      [2, "x", "abx"],
      [1, "あ", "aあb"],
    ];

    for (const [col, ch, want] of cases) {
      const buf = new TextBuffer("ab");
      buf.move("end"); // go to col 2
      while (buf.getCursor()[1] > col) {
        buf.move("left");
      }
      buf.insert(ch);
      expect(buf.getText()).toBe(want);
      expect(buf.getCursor()).toEqual([0, col + 1]);
    }
  });

  /* ------------------------------------------------------------------ */
  /*  insert_char – newline support                                      */
  /* ------------------------------------------------------------------ */
  it("insert_char with a newline should split the line", () => {
    const buf = new TextBuffer("ab");
    // jump to end of first (and only) line
    buf.move("end");
    // Insert a raw \n character – the Rust implementation splits the line
    buf.insert("\n");

    // We expect the text to be split into two separate lines
    expect(buf.getLines()).toEqual(["ab", ""]);
    expect(buf.getCursor()).toEqual([1, 0]);
  });

  /* ------------------------------------------------------------------ */
  /*  insert_str helpers                                                 */
  /* ------------------------------------------------------------------ */
  it("insert_str should insert multi‑line strings", () => {
    const initial = ["ab", "cd", "ef"].join("\n");
    const buf = new TextBuffer(initial);

    // place cursor at (row:0, col:0)
    // No move needed – cursor starts at 0,0

    buf.insertStr("x\ny");

    const wantLines = ["x", "yab", "cd", "ef"];
    expect(buf.getLines()).toEqual(wantLines);
    expect(buf.getCursor()).toEqual([1, 1]);
  });

  /* ------------------------------------------------------------------ */
  /*  Undo / Redo                                                        */
  /* ------------------------------------------------------------------ */
  it("undo / redo history should revert edits", () => {
    const buf = new TextBuffer("hello");
    buf.move("end");
    buf.insert("!"); // text becomes "hello!"

    expect(buf.undo()).toBe(true);
    expect(buf.getText()).toBe("hello");

    expect(buf.redo()).toBe(true);
    expect(buf.getText()).toBe("hello!");
  });

  /* ------------------------------------------------------------------ */
  /*  Selection model                                                    */
  /* ------------------------------------------------------------------ */
  it("copy & paste should operate on current selection", () => {
    const buf = new TextBuffer("hello world");
    buf.startSelection();
    // Select the word "hello"
    buf.move("right"); // h
    buf.move("right"); // e
    buf.move("right"); // l
    buf.move("right"); // l
    buf.move("right"); // o
    buf.endSelection();
    buf.copy();

    // Move to end and paste
    buf.move("end");
    // add one space before pasting copied word
    buf.insert(" ");
    buf.paste();

    expect(buf.getText()).toBe("hello world hello");
  });

  /* ------------------------------------------------------------------ */
  /*  Backspace behaviour                                                */
  /* ------------------------------------------------------------------ */

  describe("backspace", () => {
    it("deletes the character to the *left* of the caret within a line", () => {
      const buf = new TextBuffer("abc");

      // Move caret after the second character ( index 2 => after 'b' )
      buf.move("right"); // -> a|bc (col 1)
      buf.move("right"); // -> ab|c (col 2)

      buf.backspace();

      expect(buf.getLines()).toEqual(["ac"]);
      expect(buf.getCursor()).toEqual([0, 1]);
    });

    it("merges with the previous line when invoked at column 0", () => {
      const buf = new TextBuffer(["ab", "cd"].join("\n"));

      // Place caret at the beginning of second line
      buf.move("down"); // row = 1, col = 0

      buf.backspace();

      expect(buf.getLines()).toEqual(["abcd"]);
      expect(buf.getCursor()).toEqual([0, 2]); // after 'b'
    });

    it("is a no-op at the very beginning of the buffer", () => {
      const buf = new TextBuffer("ab");
      buf.backspace(); // caret starts at (0,0)

      expect(buf.getLines()).toEqual(["ab"]);
      expect(buf.getCursor()).toEqual([0, 0]);
    });
  });

  describe("cursor initialization", () => {
    it("initializes cursor to (0,0) by default", () => {
      const buf = new TextBuffer("hello\nworld");
      expect(buf.getCursor()).toEqual([0, 0]);
    });

    it("sets cursor to valid position within line", () => {
      const buf = new TextBuffer("hello", 2);
      expect(buf.getCursor()).toEqual([0, 2]); // cursor at 'l'
    });

    it("sets cursor to end of line", () => {
      const buf = new TextBuffer("hello", 5);
      expect(buf.getCursor()).toEqual([0, 5]); // cursor after 'o'
    });

    it("sets cursor across multiple lines", () => {
      const buf = new TextBuffer("hello\nworld", 7);
      expect(buf.getCursor()).toEqual([1, 1]); // cursor at 'o' in 'world'
    });

    it("defaults to position 0 for invalid index", () => {
      const buf = new TextBuffer("hello", 999);
      expect(buf.getCursor()).toEqual([0, 0]);
    });
  });

  /* ------------------------------------------------------------------ */
  /*  Vertical cursor movement – we should preserve the preferred column  */
  /* ------------------------------------------------------------------ */

  describe("up / down navigation keeps the preferred column", () => {
    it("restores horizontal position when moving across shorter lines", () => {
      // Three lines: long / short / long
      const lines = ["abcdef", "x", "abcdefg"].join("\n");
      const buf = new TextBuffer(lines);

      // Place caret after the 5th char in first line (col = 5)
      buf.move("end"); // col 6 (after 'f')
      buf.move("left"); // col 5 (between 'e' and 'f')

      // Move down twice – through a short line and back to a long one
      buf.move("down"); // should land on (1, 1) due to clamp
      buf.move("down"); // desired: (2, 5)

      expect(buf.getCursor()).toEqual([2, 5]);
    });
  });

  /* ------------------------------------------------------------------ */
  /*  Left / Right arrow navigation across Unicode surrogate pairs       */
  /* ------------------------------------------------------------------ */

  describe("left / right navigation", () => {
    it("should treat multi‑code‑unit emoji as a single character", () => {
      // '🐶' is a surrogate‑pair (length 2) but one user‑perceived char.
      const buf = new TextBuffer("🐶a");

      // Move caret once to the right – logically past the emoji.
      buf.move("right");

      // Insert another printable character
      buf.insert("x");

      // We expect the emoji to stay intact and the text to be 🐶xa
      expect(buf.getLines()).toEqual(["🐶xa"]);
      // Cursor should be after the inserted char (two visible columns along)
      expect(buf.getCursor()).toEqual([0, 2]);
    });
  });

  /* ------------------------------------------------------------------ */
  /*  HandleInput – raw DEL bytes should map to backspace                */
  /* ------------------------------------------------------------------ */

  it("handleInput should treat \x7f input as backspace", () => {
    const buf = new TextBuffer("");
    const vp = { width: 80, height: 25 };

    // Type "hello" via printable input path
    for (const ch of "hello") {
      buf.handleInput(ch, {}, vp);
    }

    // Two DEL bytes – terminal's backspace
    buf.handleInput("\x7f", {}, vp);
    buf.handleInput("\x7f", {}, vp);

    expect(buf.getText()).toBe("hel");
    expect(buf.getCursor()).toEqual([0, 3]);
  });

  /* ------------------------------------------------------------------ */
  /*  HandleInput – `key.delete` should ALSO behave as backspace          */
  /* ------------------------------------------------------------------ */

  it("handleInput should treat key.delete as backspace", () => {
    const buf = new TextBuffer("");
    const vp = { width: 80, height: 25 };

    for (const ch of "hello") {
      buf.handleInput(ch, {}, vp);
    }

    // Simulate the Delete (Mac backspace) key three times
    buf.handleInput(undefined, { delete: true }, vp);
    buf.handleInput(undefined, { delete: true }, vp);
    buf.handleInput(undefined, { delete: true }, vp);

    expect(buf.getText()).toBe("he");
    expect(buf.getCursor()).toEqual([0, 2]);
  });

  /* ------------------------------------------------------------------ */
  /*  Cursor positioning semantics                                       */
  /* ------------------------------------------------------------------ */

  describe("cursor movement & backspace semantics", () => {
    it("typing should leave cursor after the last inserted character", () => {
      const vp = { width: 80, height: 25 };
      const buf = new TextBuffer("");

      buf.handleInput("h", {}, vp);
      expect(buf.getCursor()).toEqual([0, 1]);

      for (const ch of "ello") {
        buf.handleInput(ch, {}, vp);
      }
      expect(buf.getCursor()).toEqual([0, 5]); // after 'o'
    });

    it("arrow‑left moves the caret to *between* characters (highlight next)", () => {
      const vp = { width: 80, height: 25 };
      const buf = new TextBuffer("");
      for (const ch of "bar") {
        buf.handleInput(ch, {}, vp);
      } // cursor at col 3

      buf.move("left"); // col 2 (right before 'r')
      buf.move("left"); // col 1 (right before 'a')

      expect(buf.getCursor()).toEqual([0, 1]);
      // Character to the RIGHT of caret should be 'a'
      const charRight = [...buf.getLines()[0]!][buf.getCursor()[1]];
      expect(charRight).toBe("a");

      // Backspace should delete the char to the *left* (i.e. 'b'), leaving "ar"
      buf.backspace();
      expect(buf.getLines()[0]).toBe("ar");
      expect(buf.getCursor()).toEqual([0, 0]);
    });
  });
});