Struct Edit 

pub struct Edit {
    pub step: u32,
    pub tool: String,
    pub path: String,
    pub lines_added: u64,
    pub lines_removed: u64,
}

One file change a run made, and how many lines it added and removed (0.18.0).

The counts come from comparing the file’s lines before and after, trimming the common head and tail — not from a minimal diff. A one-line replacement is therefore one added and one removed, and a rewrite of the middle of a file is the size of that middle. It answers “how much did this run change” without the crate carrying a diff algorithm it has no other use for.

use io_harness::{Edit, Store};

// A run writes rows like this itself; recorded by hand here so the example
// needs no model.
store.record_edit(run_id, &Edit::measure(
    2,
    "edit_file",
    "src/parse.rs",
    "fn parse() {}\nfn other() {}\n",
    "fn parse(s: &str) {}\nfn other() {}\n",
))?;

let edits = store.edits(run_id)?;
assert_eq!(edits[0].path, "src/parse.rs");
// One line out, one line in — the untouched line is not counted as either.
assert_eq!((edits[0].lines_added, edits[0].lines_removed), (1, 1));

Fields

step: u32

The step that made the change.

tool: String

The tool that made it — write_file or edit_file.

path: String

The path, as the agent named it (relative to the workspace root).

lines_added: u64

Lines present after and not before.

lines_removed: u64

Lines present before and not after.

Implementations

impl Edit

pub fn measure(step: u32, tool: &str, path: &str, old: &str, new: &str) -> Self

The change new makes to old, by common head and tail comparison.

use io_harness::Edit;

// A one-line replacement inside a file: one line out, one line in.
let edit = Edit::measure(1, "edit_file", "a.rs", "fn one() {}\nfn two() {}\n",
                                                "fn one() {}\nfn three() {}\n");
assert_eq!((edit.lines_added, edit.lines_removed), (1, 1));

// A new file is all addition; rewriting a file with what it already held
// is neither, which is the fact a byte-count would have missed.
assert_eq!(Edit::measure(1, "write_file", "b.rs", "", "one\ntwo\n").lines_added, 2);
let same = Edit::measure(1, "write_file", "b.rs", "one\ntwo\n", "one\ntwo\n");
assert_eq!((same.lines_added, same.lines_removed), (0, 0));

Trait Implementations

impl Clone for Edit

fn clone(&self) -> Edit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Edit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Edit

fn default() -> Edit

Returns the “default value” for a type.

impl Eq for Edit

impl PartialEq for Edit

fn eq(&self, other: &Edit) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Edit