fixes #3

Author: jph00

DEV.md

@@ -45,6 +45,10 @@ tools/build.sh release
 cargo test && pytest -q
 ```
 
+## Hash verification timing
+
+`edit_text` verifies lnhashes command-by-command against the current in-memory buffer, immediately before each command executes (not all upfront). If an earlier command shifts or rewrites a later target line, that later command will fail with a stale-hash error unless you recompute addresses.
+
 ## Release
 
 Publishing is handled by GitHub Actions in `.github/workflows/ci.yml` and is triggered by pushing a tag matching `v*`.

README.md

@@ -48,6 +48,8 @@ EOF
 exhash --dry-run file.txt '12|abcd|d'
 ```
 
+When passing multiple commands, each command's lnhashes are verified immediately before that command runs.
+
 For `a/i/c` commands, provide the text block on stdin:
 
 ```bash
@@ -77,7 +79,7 @@ view = lnhashview(text)  # ["1|a1b2|  foo", "2|c3d4|  bar"]
 
 ### Editing
 
-`exhash(text, cmds)` takes the text and a required list of command strings (use `[]` for no-op). For `a`/`i`/`c` commands, lines after the command are the text block (no `.` terminator needed):
+`exhash(text, cmds)` takes the text and a required iterable of command strings (use `[]` for no-op). For `a`/`i`/`c` commands, lines after the command are the text block (no `.` terminator needed):
 
 ```py
 addr = lnhash(1, "foo")  # "1|a1b2|"
@@ -89,6 +91,9 @@ print(res["modified"]) # [1]
 a1, a2 = lnhash(1, "foo"), lnhash(2, "bar")
 res = exhash(text, [f"{a1}s/foo/FOO/", f"{a2}s/bar/BAR/"])
 
+# Hashes are checked just-in-time per command.
+# If earlier commands change/shift a later target line, recompute lnhash first.
+
 # Append multiline text (no dot terminator)
 res = exhash(text, [f"{addr}a\nnew line 1\nnew line 2"])
 ```

python/exhash/__init__.py

@@ -16,7 +16,7 @@ def lnhashview(text:str) -> list[str]:
 
 
 def exhash_result(results:list[dict]) -> str:
-    """Format modified lines from exhash result dicts in lnhash view format."""
+    '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:
@@ -34,6 +34,8 @@ def exhash(text:str, cmds:list[str]) -> dict:
     Commands use lnhash addresses: ``lineno|hash|cmd`` where hash is a 4-char
     hex content hash. Use ``lnhashview(text)`` or ``lnhash(lineno, line)`` to
     get addresses.
+    Each command's hashes are verified against current text immediately before
+    that command executes.
 
     Addressing:
       Single:   ``12|a3f2|cmd``
@@ -65,8 +67,8 @@ def exhash(text:str, cmds:list[str]) -> dict:
       modified  1-based line numbers of modified/added lines
       deleted   1-based line numbers of removed lines (in original)
 
-    `cmds` is a required list of command strings. For `a`/`i`/`c`, include the
-    text block in the same command string after a newline.
+    `cmds` is a required iterable of command strings. For `a`/`i`/`c`, include
+    the text block in the same command string after a newline.
 
     Examples::
 

src/bin/exhash.rs

@@ -17,6 +17,7 @@ ADDRESSING
   hex content hash. Use lnhashview to get addresses:
     lnhashview file.txt          show all lines with addresses
     lnhashview file.txt 10 20    show lines 10-20
+  With multiple commands, hashes are checked immediately before each command runs.
 
   Single:   12|a3f2|cmd
   Range:    12|a3f2|,15|b1c3|cmd

src/engine.rs

@@ -61,6 +61,62 @@ impl Engine {
         self.apply_subcommand(start, end, cmd.has_comma, &cmd.cmd)
     }
 
+    fn verify_command(&self, cmd: &Command) -> Result<(), EditError> {
+        self.verify_lnhash(cmd.addr1, &cmd.cmd)?;
+        if let Some(a2) = cmd.addr2 {
+            self.verify_lnhash(a2, &cmd.cmd)?;
+        }
+        self.verify_subcommand_refs(&cmd.cmd)?;
+        Ok(())
+    }
+
+    fn verify_subcommand_refs(&self, cmd: &Subcommand) -> Result<(), EditError> {
+        match cmd {
+            Subcommand::Move { dest } | Subcommand::Copy { dest } => {
+                self.verify_lnhash_basic(*dest)?;
+                Ok(())
+            }
+            Subcommand::Global { cmd, .. } => self.verify_subcommand_refs(cmd),
+            _ => Ok(()),
+        }
+    }
+
+    fn verify_lnhash(&self, addr: crate::LnHash, cmd: &Subcommand) -> Result<(), EditError> {
+        if addr.lineno == 0 {
+            // Only valid for i/a, enforced by parser.
+            if addr.hash != 0 {
+                return Err(EditError::new("0|0000| must have hash 0000"));
+            }
+            match cmd {
+                Subcommand::Append(_) | Subcommand::Insert(_) => Ok(()),
+                _ => Err(EditError::new("0|0000| is only valid with i or a")),
+            }
+        } else {
+            self.verify_lnhash_basic(addr)
+        }
+    }
+
+    fn verify_lnhash_basic(&self, addr: crate::LnHash) -> Result<(), EditError> {
+        if addr.lineno == 0 {
+            return Err(EditError::new("address 0 is not allowed here"));
+        }
+        if addr.lineno > self.lines.len() {
+            return Err(EditError::new(format!(
+                "address out of range: {} > {}",
+                addr.lineno,
+                self.lines.len()
+            )));
+        }
+        let actual = line_hash_u16(&self.lines[addr.lineno - 1].text);
+        if actual != addr.hash {
+            return Err(EditError::new(format!(
+                "stale lnhash at line {}: expected {:04x}, got {:04x}",
+                addr.lineno, addr.hash, actual
+            )));
+        }
+        Ok(())
+    }
+
     fn apply_subcommand(
         &mut self,
         start: usize,
@@ -441,14 +497,14 @@ impl Engine {
 
 /// Apply `commands` to the input text.
 ///
-/// All lnhashes in the command list are verified against `input` before any edits are applied.
+/// Each command's lnhashes are verified against the current text immediately before that
+/// command is applied.
 pub fn edit_text(input: &str, commands: &[Command]) -> Result<EditResult, EditError> {
     let input_lines: Vec<String> = input.lines().map(|l| l.to_string()).collect();
 
-    verify_all(&input_lines, commands)?;
-
     let mut eng = Engine::new(input_lines);
     for c in commands {
+        eng.verify_command(c)?;
         eng.apply_command(c)?;
     }
 
@@ -476,64 +532,6 @@ pub fn edit_text(input: &str, commands: &[Command]) -> Result<EditResult, EditEr
     })
 }
 
-fn verify_all(input_lines: &[String], commands: &[Command]) -> Result<(), EditError> {
-    for c in commands {
-        verify_lnhash(input_lines, c.addr1, &c.cmd)?;
-        if let Some(a2) = c.addr2 {
-            verify_lnhash(input_lines, a2, &c.cmd)?;
-        }
-        verify_subcommand_refs(input_lines, &c.cmd)?;
-    }
-    Ok(())
-}
-
-fn verify_subcommand_refs(input_lines: &[String], cmd: &Subcommand) -> Result<(), EditError> {
-    match cmd {
-        Subcommand::Move { dest } | Subcommand::Copy { dest } => {
-            verify_lnhash_basic(input_lines, *dest)?;
-            Ok(())
-        }
-        Subcommand::Global { cmd, .. } => verify_subcommand_refs(input_lines, cmd),
-        _ => Ok(()),
-    }
-}
-
-fn verify_lnhash(input_lines: &[String], addr: crate::LnHash, cmd: &Subcommand) -> Result<(), EditError> {
-    if addr.lineno == 0 {
-        // Only valid for i/a, enforced by parser.
-        if addr.hash != 0 {
-            return Err(EditError::new("0|0000| must have hash 0000"));
-        }
-        match cmd {
-            Subcommand::Append(_) | Subcommand::Insert(_) => Ok(()),
-            _ => Err(EditError::new("0|0000| is only valid with i or a")),
-        }
-    } else {
-        verify_lnhash_basic(input_lines, addr)
-    }
-}
-
-fn verify_lnhash_basic(input_lines: &[String], addr: crate::LnHash) -> Result<(), EditError> {
-    if addr.lineno == 0 {
-        return Err(EditError::new("address 0 is not allowed here"));
-    }
-    if addr.lineno > input_lines.len() {
-        return Err(EditError::new(format!(
-            "address out of range: {} > {}",
-            addr.lineno,
-            input_lines.len()
-        )));
-    }
-    let actual = line_hash_u16(&input_lines[addr.lineno - 1]);
-    if actual != addr.hash {
-        return Err(EditError::new(format!(
-            "stale lnhash at line {}: expected {:04x}, got {:04x}",
-            addr.lineno, addr.hash, actual
-        )));
-    }
-    Ok(())
-}
-
 fn build_regex(pattern: &str, case_insensitive: bool) -> Result<Regex, EditError> {
     if case_insensitive {
         RegexBuilder::new(pattern)
@@ -780,18 +778,16 @@ mod tests {
     }
 
     #[test]
-    fn multi_command_line_numbers_shift() {
+    fn multi_command_rechecks_hashes_after_each_command() {
         let input = "a\nb\nc\n";
-        // Insert X before line 2, then delete line 3 (which was originally 2 before insertion? actually after insertion, line3 is original b)
+        // Insert X before line 2, then try to delete original line 3 by stale lnhash.
         let script = format!(
             "{}i\nX\n.\n{}d\n",
             addr(2, "b"),
             addr(3, "c")
         );
         let cmds = parse_commands_from_script(&script).unwrap();
-        let res = edit_text(input, &cmds).unwrap();
-        // After insertion: a, X, b, c. Then delete line3 -> b removed.
-        assert_eq!(res.lines, vec!["a".to_string(), "X".to_string(), "c".to_string()]);
-        assert_eq!(res.deleted, vec![2]);
+        let err = edit_text(input, &cmds).unwrap_err();
+        assert!(err.message().contains("stale lnhash at line 3"));
     }
 }

tests/cli.rs

@@ -130,6 +130,30 @@ fn exhash_rejects_stale_lnhash_and_leaves_file_unchanged() {
     assert_eq!(read_file(&file), "HELLO\nworld\n");
 }
 
+#[test]
+fn exhash_rechecks_hashes_between_commands() {
+    let dir = mk_temp_dir("exhash_stale_between_commands");
+    let file = dir.join("f.txt");
+    write_file(&file, "a\nb\n");
+
+    let a1 = format_lnhash(1, "a");
+    let cmd1 = format!("{}s/a/A/", a1);
+    let cmd2 = format!("{}d", a1);
+
+    let bin = env!("CARGO_BIN_EXE_exhash");
+    let out = Command::new(bin)
+        .arg(&file)
+        .arg(cmd1)
+        .arg(cmd2)
+        .output()
+        .unwrap();
+    assert!(!out.status.success());
+    assert!(String::from_utf8(out.stderr).unwrap().contains("stale lnhash"));
+
+    // No partial write on command failure.
+    assert_eq!(read_file(&file), "a\nb\n");
+}
+
 #[test]
 fn exhash_multiline_append_from_stdin() {
     let dir = mk_temp_dir("exhash_multiline");

tests/test_exhash.py

@@ -107,6 +107,11 @@ def test_exhash_multiple_cmds():
     assert res["lines"] == ["A", "b", "C"]
     assert res["modified"] == [1, 3]
 
+def test_exhash_rechecks_hash_before_each_command():
+    text = "a\nb\nc\n"
+    a2, a3 = lnhash(2, "b"), lnhash(3, "c")
+    with pytest.raises(ValueError, match="stale"): exhash(text, [f"{a2}i\nx", f"{a3}d"])
+
 def test_exhash_append_trailing_newline():
     text = "a\nb\n"
     addr = lnhash(1, "a")
@@ -118,7 +123,8 @@ def test_exhash_multiline_non_text_cmd_raises():
     addr = lnhash(1, "a")
     with pytest.raises(ValueError): exhash(text, [f"{addr}d\nextra"])
 
-def test_exhash_requires_list_cmds():
+def test_exhash_accepts_tuple_cmds():
     text = "a\nb\n"
     a1, a2 = lnhash(1, "a"), lnhash(2, "b")
-    with pytest.raises(TypeError): exhash(text, (f"{a1}s/a/A/", f"{a2}s/b/B/"))
+    res = exhash(text, (f"{a1}s/a/A/", f"{a2}s/b/B/"))
+    assert res["lines"] == ["A", "B"]