bump

Author: jph00

Cargo.toml

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

README.md

@@ -72,6 +72,8 @@ Substitute uses Rust regex syntax:
 - Pattern syntax is from [`regex`](https://docs.rs/regex/latest/regex/)
 - Replacement syntax is from [`regex::Replacer`](https://docs.rs/regex/latest/regex/struct.Regex.html#method.replace), e.g. `$1`, `$0`, `${name}`
 - `\/` escapes the command delimiter in pattern/replacement
+- Custom delimiters: `s`, `y`, `g`, `g!`, and `v` all accept any non-alphanumeric char as delimiter instead of `/`, e.g. `s@pat@rep@`, `g@pat@cmd`. Each command in a combo picks its own delimiter independently: `g@a/b@s/old/new/`
+- Literal newlines in pattern/replacement are supported (joins/splits lines as needed)
 - Transliteration uses `y/src/dst/` and requires source/destination to have equal character counts
 
 When passing multiple commands, each command's lnhashes are verified immediately before that command runs.
@@ -93,14 +95,15 @@ In `--stdin` mode, multiline `a/i/c` text blocks are not available.
 ## Python API
 
 ```py
-from exhash import exhash, exhash_result, lnhash, lnhashview, line_hash
+from exhash import exhash, exhash_file, exhash_result, lnhash, lnhashview, lnhashview_file, line_hash
 ```
 
 ### Viewing
 
 ```py
 text = "foo\nbar\n"
-view = lnhashview(text)  # ["1|a1b2|  foo", "2|c3d4|  bar"]
+view = lnhashview(text)       # ["1|a1b2|  foo", "2|c3d4|  bar"]
+view = lnhashview_file("f.py") # same but reads from file
 ```
 
 ### Editing
@@ -125,6 +128,27 @@ res = exhash(text, [f"{addr}a\nnew line 1\nnew line 2"])
 
 # Change shift width for < and >
 res = exhash(text, [f"{addr}>1"], sw=2)
+
+# Custom delimiters (useful when pattern/replacement contains /)
+res = exhash(text, [f"{addr}s|foo|bar|"])
+
+# Literal newlines in pattern/replacement (joins/splits lines)
+a1, a2 = lnhash(1, "foo"), lnhash(2, "bar")
+res = exhash("foo\nbar\n", [f"{a1},{a2}s/foo\nbar/replaced/"])
+```
+
+### File helpers
+
+`exhash_file` and `lnhashview_file` read directly from a file path:
+
+```py
+view = lnhashview_file("file.py")
+
+# Returns result dict, 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)
 ```
 
 ### Result dict

pyproject.toml

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

python/exhash/__init__.py

@@ -53,7 +53,10 @@ def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
     Commands:
       s/pat/rep/[flags]  Substitute using Rust regex syntax.
                          Replacement supports $1, $0, ${name}. Flags: g=all, i=case-insensitive
-      y/src/dst/         Transliterate chars in-place (source and destination lengths must match)
+                         Any non-alphanumeric delimiter works: s@pat@rep@, s|pat|rep|g
+                         Literal newlines in pat/rep are supported (joins/splits lines)
+      y/src/dst/         Transliterate chars in-place (also supports custom delimiters;
+                         source and destination lengths must match)
       d                  Delete line(s)
       a                  Append text after line
       i                  Insert text before line
@@ -65,8 +68,8 @@ def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
       <[n]               Dedent n levels (default 1, `sw` spaces each)
       sort               Sort lines alphabetically
       p                  Print (include in output without changing)
-      g/pat/cmd          Global: run cmd on matching lines
-      g!/pat/cmd         Inverted global (also v/pat/cmd)
+      g/pat/cmd          Global: run cmd on matching lines (custom delimiters ok: g@pat@cmd)
+      g!/pat/cmd         Inverted global (also v/pat/cmd; custom delimiters ok)
 
     `sw` controls shift width for `<` and `>` and defaults to 4.
 

src/engine.rs

@@ -261,20 +261,42 @@ impl Engine {
     fn substitute_range(&mut self, start: usize, end: usize, s: &Subst) -> Result<(), EditError> {
         let (s_idx, e_idx) = self.resolve_range(start, end)?;
         let re = build_regex(&s.pattern, s.case_insensitive)?;
-        for idx in s_idx..=e_idx {
-            let old = self.lines[idx].text.clone();
-            let new = if s.global {
-                re.replace_all(&old, s.replacement.as_str()).to_string()
+        let multiline = s.pattern.contains('\n') || s.replacement.contains('\n');
+        if multiline {
+            // Join range into single string, apply substitute, split back
+            let joined: String = (s_idx..=e_idx)
+                .map(|i| self.lines[i].text.as_str())
+                .collect::<Vec<_>>()
+                .join("\n");
+            let result = if s.global {
+                re.replace_all(&joined, s.replacement.as_str()).to_string()
             } else {
-                // replace first match
-                if !re.is_match(&old) {
-                    continue;
-                }
-                re.replace(&old, s.replacement.as_str()).to_string()
+                if !re.is_match(&joined) { return Ok(()); }
+                re.replace(&joined, s.replacement.as_str()).to_string()
             };
-            if new != old {
-                self.lines[idx].text = new;
-                self.lines[idx].modified = true;
+            if result == joined { return Ok(()); }
+            let new_lines: Vec<String> = result.split('\n').map(|s| s.to_string()).collect();
+            let origins: Vec<Option<usize>> = (s_idx..=e_idx).map(|i| self.lines[i].origin).collect();
+            let new_line_objs: Vec<Line> = new_lines.into_iter().enumerate().map(|(i, text)| Line {
+                text,
+                origin: origins.get(i).copied().flatten(),
+                modified: true,
+                global_mark: false,
+            }).collect();
+            self.lines.splice(s_idx..=e_idx, new_line_objs);
+        } else {
+            for idx in s_idx..=e_idx {
+                let old = self.lines[idx].text.clone();
+                let new = if s.global {
+                    re.replace_all(&old, s.replacement.as_str()).to_string()
+                } else {
+                    if !re.is_match(&old) { continue; }
+                    re.replace(&old, s.replacement.as_str()).to_string()
+                };
+                if new != old {
+                    self.lines[idx].text = new;
+                    self.lines[idx].modified = true;
+                }
             }
         }
         Ok(())
@@ -684,7 +706,7 @@ fn dedent(line: &str, levels: usize, sw: usize) -> String {
 mod tests {
     use super::*;
     use crate::lnhash::{format_lnhash, line_hash_u16};
-    use crate::parse::parse_commands_from_script;
+    use crate::parse::{parse_commands_from_script, parse_commands_from_strs};
 
     fn addr(lineno: usize, line: &str) -> String {
         format_lnhash(lineno, line)
@@ -985,4 +1007,31 @@ mod tests {
         let err = edit_text(input, &cmds).unwrap_err();
         assert!(err.message().contains("stale lnhash at line 3"));
     }
+
+    #[test]
+    fn substitute_multiline_pattern_joins_and_replaces() {
+        let input = "foo\nbar\nbaz\n";
+        let cmd_str = format!("{},{}s/foo\nbar/replaced/", addr(1, "foo"), addr(2, "bar"));
+        let cmds = parse_commands_from_strs(&[&cmd_str]).unwrap();
+        let res = edit_text(input, &cmds).unwrap();
+        assert_eq!(res.lines, vec!["replaced", "baz"]);
+    }
+
+    #[test]
+    fn substitute_newline_in_replacement_splits_line() {
+        let input = "foobar\nbaz\n";
+        let cmd_str = format!("{}s/foobar/foo\nbar/", addr(1, "foobar"));
+        let cmds = parse_commands_from_strs(&[&cmd_str]).unwrap();
+        let res = edit_text(input, &cmds).unwrap();
+        assert_eq!(res.lines, vec!["foo", "bar", "baz"]);
+    }
+
+    #[test]
+    fn substitute_custom_delimiter() {
+        let input = "a/b\n";
+        let cmd = format!("{}s|a/b|c/d|", addr(1, "a/b"));
+        let cmds = parse_commands_from_script(&cmd).unwrap();
+        let res = edit_text(input, &cmds).unwrap();
+        assert_eq!(res.lines, vec!["c/d"]);
+    }
 }