Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust
9.7 KB
Raw Blame
//! Paste-marker behavior tests: the atomic-marker and paste-snapshot
//! suites.

use super::*;
use wrap::{segment_with_markers, word_wrap_line};

fn ed() -> Editor {
    Editor::new()
}

fn paste_with_marker(e: &mut Editor, lines: usize) {
    let text = "line\n".repeat(lines);
    let text = text.trim_end().to_string();
    e.handle_paste(&text);
}

/// Length of the first marker in the editor text (TS `markerLength`).
fn marker_len(e: &Editor) -> usize {
    let text = e.get_text();
    let start = text.find("[paste #").expect("marker text");
    let end = text[start..].find(']').expect("marker end") + start + 1;
    text[start..end].chars().count()
}

fn cursor(e: &Editor) -> (usize, usize) {
    e.get_cursor()
}

#[test]
fn marker_is_a_single_unit_for_the_right_arrow() {
    let mut e = ed();
    e.handle_input("A");
    paste_with_marker(&mut e, 20);
    e.handle_input("B");
    let m = marker_len(&e);

    e.handle_input("home");
    assert_eq!(cursor(&e), (0, 0));
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, 1));
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, 1 + m), "the marker is crossed whole");
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, 2 + m));
}

#[test]
fn marker_is_a_single_unit_for_the_left_arrow() {
    let mut e = ed();
    e.handle_input("A");
    paste_with_marker(&mut e, 20);
    e.handle_input("B");
    let m = marker_len(&e);
    assert_eq!(cursor(&e), (0, 2 + m));

    e.handle_input("left");
    assert_eq!(cursor(&e), (0, 1 + m), "the marker is crossed whole");
    e.handle_input("left");
    assert_eq!(cursor(&e), (0, 1));
    e.handle_input("left");
    assert_eq!(cursor(&e), (0, 0));
}

#[test]
fn marker_is_a_single_unit_for_backspace() {
    let mut e = ed();
    e.handle_input("A");
    paste_with_marker(&mut e, 20);
    e.handle_input("B");

    e.handle_input("home");
    e.handle_input("right");
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, 1 + marker_len(&e)));
    e.handle_input("backspace");
    assert_eq!(e.get_text(), "AB", "the marker is deleted whole");
    assert_eq!(cursor(&e), (0, 1));
}

#[test]
fn marker_is_a_single_unit_for_forward_delete() {
    let mut e = ed();
    e.handle_input("A");
    paste_with_marker(&mut e, 20);
    e.handle_input("B");

    e.handle_input("home");
    e.handle_input("right");
    e.handle_input("delete");
    assert_eq!(e.get_text(), "AB", "the marker is deleted whole");
    assert_eq!(cursor(&e), (0, 1));
}

#[test]
fn marker_is_a_single_unit_for_word_movement() {
    let mut e = ed();
    e.handle_input("X");
    e.handle_input(" ");
    paste_with_marker(&mut e, 20);
    e.handle_input(" ");
    e.handle_input("Y");
    let m = marker_len(&e);

    e.handle_input("home");
    e.handle_input("alt+right");
    assert_eq!(cursor(&e), (0, 1));
    e.handle_input("alt+right");
    assert_eq!(cursor(&e), (0, 2 + m), "the marker is crossed whole");
}

#[test]
fn undo_restores_marker_after_backspace_deletion() {
    let mut e = ed();
    e.handle_input("A");
    paste_with_marker(&mut e, 20);
    e.handle_input("B");
    let text_before = e.get_text();
    let content = e.get_expanded_text();

    e.handle_input("home");
    e.handle_input("right");
    e.handle_input("right");
    e.handle_input("backspace");
    assert_eq!(e.get_text(), "AB");

    e.handle_input("ctrl+-");
    assert_eq!(e.get_text(), text_before);
    assert_eq!(e.get_expanded_text(), content, "the registry restores too");
}

#[test]
fn multiple_markers_in_the_same_line_stay_atomic() {
    let mut e = ed();
    paste_with_marker(&mut e, 20);
    e.handle_input(" ");
    paste_with_marker(&mut e, 30);
    let first = marker_len(&e);
    let text = e.get_text();
    let second = {
        let second_start = text.rfind("[paste #").expect("second marker");
        text[second_start..].chars().count()
    };

    e.handle_input("home");
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, first));
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, first + 1));
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, first + 1 + second));
}

#[test]
fn typed_marker_like_text_is_not_atomic() {
    let mut e = ed();
    // The chars-shaped head avoids typing "+" before the term-keys lane's
    // literal-plus decode fix lands; the shape is the same for the
    // atomicity property under test.
    let fake_marker = "[paste #99 500 chars]";
    for ch in fake_marker.chars() {
        e.handle_input(&ch.to_string());
    }
    assert_eq!(e.get_text(), fake_marker);

    e.handle_input("home");
    e.handle_input("right");
    assert_eq!(cursor(&e), (0, 1), "an unregistered marker moves by char");
}

#[test]
fn oversized_marker_never_exceeds_the_render_width() {
    let cases: [(&str, usize, &str, usize); 3] = [
        ("", 47, "", 8),
        (&"b".repeat(35), 27, "bbbb", 54),
        (&format!(" {}", "b".repeat(35)), 27, "bbbb", 54),
    ];
    for (before, lines, after, width) in cases {
        let mut e = ed();
        for ch in before.chars() {
            e.handle_input(&ch.to_string());
        }
        paste_with_marker(&mut e, lines);
        for ch in after.chars() {
            e.handle_input(&ch.to_string());
        }
        assert!(marker_len(&e) > 0);
        for line in e.layout_text(width) {
            assert!(
                crate::width::str_width(&line.text) <= width,
                "line exceeds width {width}: {:?}",
                line.text
            );
        }
    }
}

#[test]
fn snap_to_marker_start_when_navigating_down_into_it() {
    let mut e = ed();
    e.set_text("12345678901234567890\n\nhello ");
    e.handle_paste(&"x".repeat(2000));
    assert!(matches!(e.handle_paste(""), PasteDisposition::Inline));
    let _ = e.layout_text(80);

    e.handle_input("up");
    e.handle_input("up");
    e.handle_input("home");
    for _ in 0..10 {
        e.handle_input("right");
    }
    assert_eq!(cursor(&e), (0, 10));

    e.handle_input("down");
    assert_eq!(cursor(&e), (1, 0));
    e.handle_input("down");
    assert_eq!(cursor(&e), (2, 6), "the cursor snaps to the marker start");
}

#[test]
fn expanded_content_survives_to_submit() {
    let mut e = ed();
    let pasted_text = (0..10)
        .map(|index| format!("line {}", index + 1))
        .chain(std::iter::once("tokens $1 $2 $& $$ $` $' end".to_string()))
        .collect::<Vec<_>>()
        .join("\n");

    e.handle_paste(&pasted_text);
    assert!(e.get_text().starts_with("[paste #"));
    assert_eq!(e.get_expanded_text(), pasted_text);

    e.handle_input("enter");
    let events = e.take_events();
    let submitted = events
        .iter()
        .find_map(|event| match event {
            EditorEvent::Submitted(text) => Some(text.clone()),
            _ => None,
        })
        .expect("submit event");
    assert_eq!(submitted, pasted_text, "the send ships the full content");
}

#[test]
fn paste_snapshot_round_trips_between_editors() {
    let pasted_text = (0..11)
        .map(|i| format!("line {}", i + 1))
        .collect::<Vec<_>>()
        .join("\n");
    let mut source = ed();
    source.handle_paste(&pasted_text);
    let marker_text = source.get_text();
    let snapshot = source.get_paste_snapshot();

    let mut restored = ed();
    restored.set_text(&marker_text);
    restored.restore_paste_snapshot(snapshot);
    assert!(marker_text.starts_with("[paste #"));
    assert_eq!(restored.get_expanded_text(), pasted_text);
}

#[test]
fn undo_restores_paste_snapshot_state() {
    let original_text = (0..11)
        .map(|i| format!("original {}", i + 1))
        .collect::<Vec<_>>()
        .join("\n");
    let restored_text = (0..12)
        .map(|i| format!("restored {}", i + 1))
        .collect::<Vec<_>>()
        .join("\n");

    let mut e = ed();
    e.handle_paste(&original_text);
    let original_marker = e.get_text();

    let mut restored_source = ed();
    restored_source.handle_paste(&restored_text);
    e.set_text(&restored_source.get_text());
    e.restore_paste_snapshot(restored_source.get_paste_snapshot());
    assert_eq!(e.get_expanded_text(), restored_text);

    e.handle_input("ctrl+-");
    assert_eq!(e.get_text(), original_marker);
    assert_eq!(e.get_expanded_text(), original_text);
}

#[test]
fn only_well_formed_registered_markers_expand() {
    let mut e = ed();
    paste_with_marker(&mut e, 20); // registers [paste #1]
    let content = paste_content(&e, 1);

    // Edited look-alikes, an unregistered id, and a longer id whose head
    // contains `#1` all stay literal; the three well-formed registered
    // shapes expand.
    e.set_text("[paste #1 junk] [paste #10] [paste #1] [paste #1 +5 lines] [paste #1 12 chars]");
    assert_eq!(
        e.get_expanded_text(),
        format!("[paste #1 junk] [paste #10] {content} {content} {content}"),
    );
}

fn paste_content(e: &Editor, id: usize) -> String {
    e.get_paste_snapshot()
        .pastes
        .into_iter()
        .find(|(pid, _)| *pid == id)
        .map(|(_, content)| content)
        .expect("registered paste")
}

#[test]
fn oversized_marker_re_wraps_visually_and_wrap_resumes_after_it() {
    // TS `wordWrapLine` atomic cases: the marker stays one logical segment
    // but re-wraps visually at grapheme granularity.
    let marker = "[paste #1 +20 lines]";
    let line = format!("A{marker}B");
    let segments = segment_with_markers(&line, &|_| true);
    let chunks = word_wrap_line(&line, 10, Some(segments));
    let texts: Vec<&str> = chunks.iter().map(|c| c.text.as_str()).collect();
    assert_eq!(texts, vec!["A", "[paste #1 ", "+20 lines]", "B"]);

    let line = format!("{marker} hello world");
    let segments = segment_with_markers(&line, &|_| true);
    let chunks = word_wrap_line(&line, 10, Some(segments));
    let texts: Vec<&str> = chunks.iter().map(|c| c.text.as_str()).collect();
    assert_eq!(texts, vec!["[paste #1 ", "+20 lines]", " hello ", "world"]);
}