fixes #10

Author: jph00

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "exhash"
-version = "0.2.7"
+version = "0.3.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Verified line-addressed file editor using lnhash addresses"

README.md

@@ -95,7 +95,7 @@ In `--stdin` mode, multiline `a/i/c` text blocks are not available.
 ## Python API
 
 ```py
-from exhash import exhash, exhash_file, exhash_result, lnhash, lnhashview, lnhashview_file, line_hash
+from exhash import exhash, exhash_file, lnhash, lnhashview, lnhashview_file, line_hash
 ```
 
 ### Viewing
@@ -144,21 +144,32 @@ res = exhash("foo\nbar\n", [f"{a1},{a2}s/foo\nbar/replaced/"])
 ```py
 view = lnhashview_file("file.py")
 
-# Returns result dict, file unchanged
+# Returns EditResult, file unchanged
 res = exhash_file("file.py", [f"{addr}s/foo/bar/"])
 
-# With inplace=True, writes back on success; no changes if any command fails
-res = exhash_file("file.py", [f"{addr}s/foo/bar/"], inplace=True)
+# With inplace=True, writes back on success and returns diff string
+diff = exhash_file("file.py", [f"{addr}s/foo/bar/"], inplace=True)
 ```
 
-### Result dict
+### EditResult
+
+`exhash()` returns an `EditResult` with attributes (also accessible via `res["key"]`):
 
 - `lines` — list of output lines
 - `hashes` — lnhash for each output line
 - `modified` — 1-based line numbers of modified/added lines
 - `deleted` — 1-based line numbers of removed lines (in original)
+- `origins` — for each output line, the 1-based original line number (None if inserted)
+
+`res.format_diff(context=1)` returns a unified-diff-style summary showing only changed lines with context:
 
-`exhash_result([res1, res2, ...])` renders modified lines in lnhash format, matching the old `repr(EditResult)` style.
+```py
+res = exhash(text, [f"{addr}s/foo/baz/"])
+print(res.format_diff())
+# -1|a1b2|  foo
+# +1|c3d4|  baz
+#  2|e5f6|  bar
+```
 
 ## Tests
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "exhash"
-version = "0.2.7"
+version = "0.3.0"
 description = "Verified line-addressed file editor using lnhash addresses"
 license = {text = "MIT OR Apache-2.0"}
 requires-python = ">=3.10"

python/exhash/__init__.py

@@ -21,21 +21,8 @@ def lnhashview_file(path:str, start:int=None, end:int=None) -> list[str]:
     return _lnhashview(Path(path).read_text(), start, end)
 
 
-def exhash_result(results:list[dict]) -> str:
-    'Format modified lines from exhash result dicts in lnhash view format.'
-    if not isinstance(results, list): raise TypeError("results must be a list[dict]")
-    out = []
-    for r in results:
-        if not isinstance(r, dict): raise TypeError("results must be a list[dict]")
-        lines, hashes, modified = r.get("lines"), r.get("hashes"), r.get("modified")
-        if not isinstance(lines, list) or not isinstance(hashes, list) or not isinstance(modified, list):
-            raise TypeError("each result must include list fields: lines, hashes, modified")
-        out += [f"{hashes[i-1]}  {lines[i-1]}" for i in modified if isinstance(i, int) and 0 < i <= len(hashes)]
-    return '\n'.join(out)
-
-
-def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
-    """Verified line-addressed editor. Apply commands to `text`, return a result dict.
+def exhash(text:str, cmds:list[str], sw:int=4):
+    """Verified line-addressed editor. Apply commands to `text`, return an EditResult.
 
     Commands primarily use lnhash addresses: ``lineno|hash|cmd`` where hash is
     a 4-char hex content hash. Use ``lnhashview(text)`` or
@@ -76,11 +63,14 @@ def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
     For a/i/c, remaining lines in the command string are the text block
     (no '.' terminator needed, unlike the CLI).
 
-    Returns a dict with:
+    Returns an EditResult with attributes (also accessible as dict keys):
       lines     list of output lines
       hashes    lnhash for each output line
       modified  1-based line numbers of modified/added lines
       deleted   1-based line numbers of removed lines (in original)
+      origins   for each output line, the 1-based original line number (None if inserted)
+
+    Call ``res.format_diff(context=1)`` for a unified-diff-style summary.
 
     `cmds` is a required iterable of command strings. For `a`/`i`/`c`, include
     the text block in the same command string after a newline.
@@ -92,16 +82,16 @@ def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
       addr = lnhash(1, "foo")           # "1|a1b2|"
       res = exhash(text, [f"{addr}s/foo/baz/"])
       print(res["lines"])                # ["baz", "bar"]
-      "\\n".join(res["lines"])           # "baz\\nbar"
-      res = exhash(text, [f"{addr}a\\nnew line 1\\nnew line 2"])
+      print(res.format_diff())           # unified-diff-style summary
     """
-    r = _exhash(text, *cmds, sw=sw)
-    return dict(lines=r.lines, hashes=r.hashes, modified=r.modified, deleted=r.deleted)
+    return _exhash(text, *cmds, sw=sw)
 
 
-def exhash_file(path:str, cmds:list[str], sw:int=4, inplace:bool=False) -> dict:
-    'Like ``exhash`` but reads from file at ``path``. If ``inplace``, writes result back (atomically on success only).'
+def exhash_file(path:str, cmds:list[str], sw:int=4, inplace:bool=False):
+    'Like ``exhash`` but reads from file at ``path``. If ``inplace``, writes back and returns diff string.'
     text = Path(path).read_text()
-    r = exhash(text, cmds, sw=sw)
-    if inplace: Path(path).write_text('\n'.join(r['lines']) + '\n' if r['lines'] else '')
+    r = _exhash(text, *cmds, sw=sw)
+    if inplace:
+        Path(path).write_text('\n'.join(r['lines']) + '\n' if r['lines'] else '')
+        return r.format_diff()
     return r

src/bin/exhash.rs

@@ -269,10 +269,7 @@ fn main() {
         }
     }
 
-    for lineno in &result.modified {
-        let i = lineno - 1;
-        if let (Some(h), Some(line)) = (result.hashes.get(i), result.lines.get(i)) {
-            println!("{h}  {line}");
-        }
-    }
+    let original_lines: Vec<&str> = text.lines().collect();
+    let diff = result.format_diff(&original_lines, 1);
+    if !diff.is_empty() { print!("{diff}"); }
 }

src/engine.rs

@@ -17,6 +17,95 @@ pub struct EditResult {
     pub modified: Vec<usize>,
     /// Old-file 1-based line numbers that were removed.
     pub deleted: Vec<usize>,
+    /// For each output line, the 1-based original line number it came from (None if inserted).
+    pub origins: Vec<Option<usize>>,
+}
+
+impl EditResult {
+    /// Format a unified-diff-style summary of changes.
+    ///
+    /// Each line is prefixed with ` ` (context), `+` (added/modified), or `-` (deleted),
+    /// followed by the lnhash and content. `context` controls how many unchanged lines
+    /// surround each hunk (default 1).
+    pub fn format_diff(&self, original_lines: &[&str], context: usize) -> String {
+        use crate::lnhash::format_lnhash;
+
+        let mod_set: BTreeSet<usize> = self.modified.iter().copied().collect();
+        let del_set: BTreeSet<usize> = self.deleted.iter().copied().collect();
+
+        // Build interleaved sequence of (tag, lnhash, text) where tag is ' ', '+', '-'
+        // Walk new lines, inserting deleted old lines at the right positions.
+        let mut events: Vec<(char, String, &str)> = Vec::new();
+        let mut next_old = 1usize; // next original line we expect
+
+        for (new_idx, line) in self.lines.iter().enumerate() {
+            let new_lineno = new_idx + 1;
+            let origin = self.origins[new_idx];
+
+            // Emit any deleted old lines that came before this line's origin
+            if let Some(orig) = origin {
+                while next_old < orig {
+                    if del_set.contains(&next_old) {
+                        let old_line = original_lines[next_old - 1];
+                        events.push(('-', format_lnhash(next_old, old_line), old_line));
+                    }
+                    next_old += 1;
+                }
+                next_old = orig + 1;
+            }
+
+            if mod_set.contains(&new_lineno) {
+                // Show the old line as deleted if this was a modification (not insertion)
+                if let Some(orig) = origin {
+                    let old_line = original_lines[orig - 1];
+                    if old_line != line.as_str() {
+                        events.push(('-', format_lnhash(orig, old_line), old_line));
+                    }
+                }
+                events.push(('+', self.hashes[new_idx].clone(), line.as_str()));
+            } else {
+                events.push((' ', self.hashes[new_idx].clone(), line.as_str()));
+            }
+        }
+
+        // Emit any remaining deleted lines at the end
+        let old_len = original_lines.len();
+        while next_old <= old_len {
+            if del_set.contains(&next_old) {
+                let old_line = original_lines[next_old - 1];
+                events.push(('-', format_lnhash(next_old, old_line), old_line));
+            }
+            next_old += 1;
+        }
+
+        // Now group into hunks with context
+        let interesting: BTreeSet<usize> = events.iter().enumerate()
+            .filter(|(_, (tag, _, _))| *tag != ' ')
+            .flat_map(|(i, _)| {
+                let start = i.saturating_sub(context);
+                let end = (i + context).min(events.len() - 1);
+                start..=end
+            })
+            .collect();
+
+        if interesting.is_empty() { return String::new(); }
+
+        let mut out = String::new();
+        let mut last: Option<usize> = None;
+        for i in &interesting {
+            if let Some(prev) = last {
+                if *i > prev + 1 { out.push_str("---\n"); }
+            }
+            let (tag, ref hash, text) = events[*i];
+            out.push(tag);
+            out.push_str(hash);
+            out.push_str("  ");
+            out.push_str(text);
+            out.push('\n');
+            last = Some(*i);
+        }
+        out
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -641,12 +730,14 @@ pub fn edit_text_with_sw(input: &str, commands: &[Command], sw: usize) -> Result
         .collect();
 
     let deleted: Vec<usize> = eng.deleted.into_iter().collect();
+    let origins: Vec<Option<usize>> = eng.lines.iter().map(|l| l.origin).collect();
 
     Ok(EditResult {
         lines,
         hashes,
         modified,
         deleted,
+        origins,
     })
 }
 

src/python.rs

@@ -12,12 +12,45 @@ struct EditResultPy {
     modified: Vec<usize>,
     #[pyo3(get)]
     deleted: Vec<usize>,
+    #[pyo3(get)]
+    origins: Vec<Option<usize>>,
+    original_text: String,
 }
 
+#[pymethods]
+impl EditResultPy {
+    #[pyo3(signature = (context=1))]
+    fn format_diff(&self, context: usize) -> String {
+        let original_lines: Vec<&str> = self.original_text.lines().collect();
+        let result = crate::EditResult {
+            lines: self.lines.clone(), hashes: self.hashes.clone(),
+            modified: self.modified.clone(), deleted: self.deleted.clone(),
+            origins: self.origins.clone(),
+        };
+        result.format_diff(&original_lines, context)
+    }
+
+    fn __str__(&self) -> String { self.format_diff(1) }
+
+    fn __repr__(&self) -> String {
+        let diff = self.format_diff(1);
+        if diff.is_empty() {
+            format!("EditResult({} lines, no changes)", self.lines.len())
+        } else {
+            format!("EditResult({} lines, {} modified, {} deleted)\n{}",
+                self.lines.len(), self.modified.len(), self.deleted.len(), diff)
+        }
+    }
 
-impl From<crate::EditResult> for EditResultPy {
-    fn from(r: crate::EditResult) -> Self {
-        Self { lines: r.lines, hashes: r.hashes, modified: r.modified, deleted: r.deleted }
+    fn __getitem__(&self, key: &str) -> PyResult<PyObject> {
+        Python::with_gil(|py| match key {
+            "lines" => Ok(self.lines.clone().into_pyobject(py)?.into_any().unbind()),
+            "hashes" => Ok(self.hashes.clone().into_pyobject(py)?.into_any().unbind()),
+            "modified" => Ok(self.modified.clone().into_pyobject(py)?.into_any().unbind()),
+            "deleted" => Ok(self.deleted.clone().into_pyobject(py)?.into_any().unbind()),
+            "origins" => Ok(self.origins.clone().into_pyobject(py)?.into_any().unbind()),
+            _ => Err(pyo3::exceptions::PyKeyError::new_err(key.to_string())),
+        })
     }
 }
 
@@ -43,7 +76,11 @@ fn py_exhash(text: &str, cmds: Vec<String>, sw: usize) -> PyResult<EditResultPy>
         .map_err(|e| PyValueError::new_err(e.to_string()))?;
     let res = crate::edit_text_with_sw(text, &parsed, sw)
         .map_err(|e| PyValueError::new_err(e.to_string()))?;
-    Ok(res.into())
+    Ok(EditResultPy {
+        lines: res.lines, hashes: res.hashes, modified: res.modified,
+        deleted: res.deleted, origins: res.origins,
+        original_text: text.to_string(),
+    })
 }
 
 #[pymodule]