griz 0.2.0

Code edits as composable primitives: find, plan, diff, apply, undo
//! The find, plan, apply, undo loop.

use crate::common::{Griz, TestResult};
use serde_json::json;

#[test]
fn find_results_become_exact_range_edits_and_undo_restores_bytes() -> TestResult {
    let griz = Griz::new()?;
    griz.write("src/a.rs", "let oldName = 1;\nuse_it(oldName);\n")?;
    griz.write("src/b.rs", "oldName();\n")?;
    let found = griz.run(&["find", "--literal", "oldName", "--expect-matches", "3"])?;
    assert_eq!(found.json["outcome"], "passed", "{}", found.json);
    let ops: Vec<_> = found.json["matches"]
        .as_array()
        .ok_or("no matches")?
        .iter()
        .map(|m| json!({ "op": "replace", "path": m["path"], "range": m["range"], "find": { "text": m["text"] }, "replace": "new_name", "expect_hash": m["file_hash"] }))
        .collect();
    let ops = serde_json::to_string(&ops)?;
    let plan = griz.id(&["plan", "--ops", &ops, "--expect-edits", "3"], "plan")?;
    let op = griz.id(&["apply", &plan, "--expect-files", "2"], "apply")?;
    assert_eq!(
        griz.read("src/a.rs")?,
        "let new_name = 1;\nuse_it(new_name);\n"
    );
    assert_eq!(griz.read("src/b.rs")?, "new_name();\n");
    griz.id(&["undo", &op], "undo")?;
    assert_eq!(
        griz.read("src/a.rs")?,
        "let oldName = 1;\nuse_it(oldName);\n"
    );
    assert_eq!(griz.read("src/b.rs")?, "oldName();\n");
    Ok(())
}

#[test]
fn patch_files_plan_like_operations() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "fn f() {\n    old();\n}\n")?;
    griz.write("change.patch", "*** Begin Patch\n*** Update File: a.rs\n@@\n fn f() {\n-    old();\n+    new();\n }\n*** End Patch\n")?;
    let plan = griz.id(&["plan", "--patch", "@change.patch"], "plan")?;
    let diff = griz.run(&["diff", &plan, "--grep", "^[-+] "])?;
    let lines: Vec<_> = diff.json["lines"]
        .as_array()
        .ok_or("no lines")?
        .iter()
        .map(|l| l["text"].clone())
        .collect();
    assert_eq!(lines, [json!("-    old();"), json!("+    new();")]);
    assert_eq!(
        diff.json["files"][0]["path"]
            .as_str()
            .map(|p| p.ends_with("a.rs")),
        Some(true)
    );
    griz.id(&["apply", &plan], "apply")?;
    assert_eq!(griz.read("a.rs")?, "fn f() {\n    new();\n}\n");
    Ok(())
}

#[test]
fn a_structural_pattern_matches_across_formatting() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "fn f() {\n    foo(1, bar, baz);\n}\n")?;
    let found = griz.run(&["find", "--pattern", "foo($A, $$$REST)"])?;
    assert_eq!(found.json["total"], 1, "{}", found.json);
    assert_eq!(found.json["matches"][0]["vars"]["A"], "1");
    assert_eq!(found.json["matches"][0]["vars"]["REST"], "bar, baz");
    Ok(())
}

#[test]
fn absorb_folds_a_formatter_run_so_undo_restores_the_pre_apply_text() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "fn  f() {}\n")?;
    let ops = r#"[{"op":"replace","path":"a.rs","find":{"text":"f()"},"replace":"g()"}]"#;
    let plan = griz.id(&["plan", "--ops", ops], "plan")?;
    let op = griz.id(&["apply", &plan], "apply")?;
    griz.write("a.rs", "fn g() {}\n")?;
    let absorbed = griz.run(&[
        "absorb",
        &op,
        "--purpose",
        "t",
        "--idempotency-key",
        "absorb",
    ])?;
    assert_eq!(absorbed.json["outcome"], "passed", "{}", absorbed.json);
    griz.id(&["undo", &op], "undo")?;
    assert_eq!(griz.read("a.rs")?, "fn  f() {}\n");
    Ok(())
}

#[test]
fn absorb_errors_on_a_path_the_operation_never_wrote() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "a\n")?;
    griz.write("untouched.rs", "u\n")?;
    let ops = r#"[{"op":"replace","path":"a.rs","find":{"text":"a"},"replace":"A"}]"#;
    let plan = griz.id(&["plan", "--ops", ops], "plan")?;
    let op = griz.id(&["apply", &plan], "apply")?;
    let run = griz.run(&[
        "absorb",
        &op,
        "--paths",
        "untouched.rs",
        "--purpose",
        "t",
        "--idempotency-key",
        "absorb",
    ])?;
    assert_eq!(run.json["code"], "VALIDATION_ERROR", "{}", run.json);
    Ok(())
}

#[test]
fn select_applies_only_the_chosen_files() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "a\n")?;
    griz.write("b.rs", "b\n")?;
    let ops = r#"[{"op":"replace","path":"a.rs","find":{"text":"a"},"replace":"A"},{"op":"replace","path":"b.rs","find":{"text":"b"},"replace":"B"}]"#;
    let plan = griz.id(&["plan", "--ops", ops], "plan")?;
    let only_b = griz.id(&["select", &plan, "--paths", "b.rs"], "select")?;
    griz.id(&["apply", &only_b], "apply")?;
    assert_eq!(
        (griz.read("a.rs")?, griz.read("b.rs")?),
        ("a\n".into(), "B\n".into())
    );
    Ok(())
}

#[test]
fn a_workspace_edit_applies_a_text_edit_and_renames_a_file() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "let oldName = 1;\n")?;
    griz.write("old.rs", "x\n")?;
    let root = griz.work.path().canonicalize()?;
    let a_uri = format!("file://{}", root.join("a.rs").display());
    let old_uri = format!("file://{}", root.join("old.rs").display());
    let new_uri = format!("file://{}", root.join("new.rs").display());
    let edit = json!({
        "documentChanges": [
            {
                "textDocument": { "uri": a_uri },
                "edits": [{
                    "range": {
                        "start": { "line": 0, "character": 4 },
                        "end": { "line": 0, "character": 11 },
                    },
                    "newText": "newName",
                }],
            },
            { "kind": "rename", "oldUri": old_uri, "newUri": new_uri },
        ],
    });
    let plan = griz.id(
        &[
            "plan",
            "--workspace-edit",
            &edit.to_string(),
            "--expect-edits",
            "3",
        ],
        "workspace-edit-plan",
    )?;
    griz.id(&["apply", &plan], "workspace-edit-apply")?;
    assert_eq!(griz.read("a.rs")?, "let newName = 1;\n");
    assert!(!griz.path("old.rs").exists());
    assert_eq!(griz.read("new.rs")?, "x\n");
    Ok(())
}

#[test]
fn a_structural_pattern_replaces_only_the_matched_capture() -> TestResult {
    let griz = Griz::new()?;
    griz.write("a.rs", "fn f() {\n    foo(old_name, 2);\n}\n")?;
    let ops = serde_json::to_string(&json!([{
        "op": "replace",
        "path": "a.rs",
        "pattern": { "pattern": "foo($A, $B)" },
        "target": "$A",
        "replace": "new_name",
    }]))?;
    let plan = griz.id(
        &["plan", "--ops", &ops, "--expect-edits", "1"],
        "pattern-plan",
    )?;
    griz.id(&["apply", &plan], "pattern-apply")?;
    assert_eq!(griz.read("a.rs")?, "fn f() {\n    foo(new_name, 2);\n}\n");
    Ok(())
}