exhash 0.2.2__tar.gz → 0.2.3__tar.gz

{exhash-0.2.2 → exhash-0.2.3}/Cargo.lock

@@ -25,7 +25,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "exhash"
-version = "0.2.2"
+version = "0.2.3"
 dependencies = [
  "pyo3",
  "regex",

{exhash-0.2.2 → exhash-0.2.3}/Cargo.toml

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

{exhash-0.2.2 → exhash-0.2.3}/DEV.md

@@ -49,6 +49,7 @@ cargo test && pytest -q
 
 `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.
 The `$` (last line) and `%` (whole file) address forms are resolved against the current buffer and do not require hashes.
+`edit_text_with_sw` exposes configurable shift width for `<` and `>`; `edit_text` defaults to `sw=4`.
 
 ## Release
 

{exhash-0.2.2 → exhash-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: exhash
-Version: 0.2.2
+Version: 0.2.3
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Summary: Verified line-addressed file editor using lnhash addresses
@@ -71,6 +71,9 @@ EOF
 # Dry-run
 exhash --dry-run file.txt '12|abcd|d'
 
+# Set shift width for < and >
+exhash --sw 2 file.txt '12|abcd|>1'
+
 # Last line and whole file shorthands (no hash)
 exhash file.txt '$d'
 exhash file.txt '%j'
@@ -117,7 +120,7 @@ view = lnhashview(text)  # ["1|a1b2|  foo", "2|c3d4|  bar"]
 
 ### Editing
 
-`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):
+`exhash(text, cmds, sw=4)` takes the text and a required iterable of command strings (use `[]` for no-op). `sw` controls how far `<` and `>` shift. For `a`/`i`/`c` commands, lines after the command are the text block (no `.` terminator needed):
 
 ```py
 addr = lnhash(1, "foo")  # "1|a1b2|"
@@ -134,6 +137,9 @@ res = exhash(text, [f"{a1}s/foo/FOO/", f"{a2}s/bar/BAR/"])
 
 # Append multiline text (no dot terminator)
 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)
 ```
 
 ### Result dict

{exhash-0.2.2 → exhash-0.2.3}/README.md

@@ -56,6 +56,9 @@ EOF
 # Dry-run
 exhash --dry-run file.txt '12|abcd|d'
 
+# Set shift width for < and >
+exhash --sw 2 file.txt '12|abcd|>1'
+
 # Last line and whole file shorthands (no hash)
 exhash file.txt '$d'
 exhash file.txt '%j'
@@ -102,7 +105,7 @@ view = lnhashview(text)  # ["1|a1b2|  foo", "2|c3d4|  bar"]
 
 ### Editing
 
-`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):
+`exhash(text, cmds, sw=4)` takes the text and a required iterable of command strings (use `[]` for no-op). `sw` controls how far `<` and `>` shift. For `a`/`i`/`c` commands, lines after the command are the text block (no `.` terminator needed):
 
 ```py
 addr = lnhash(1, "foo")  # "1|a1b2|"
@@ -119,6 +122,9 @@ res = exhash(text, [f"{a1}s/foo/FOO/", f"{a2}s/bar/BAR/"])
 
 # Append multiline text (no dot terminator)
 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)
 ```
 
 ### Result dict

{exhash-0.2.2 → exhash-0.2.3}/pyproject.toml

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

{exhash-0.2.2 → exhash-0.2.3}/python/exhash/__init__.py

@@ -28,7 +28,7 @@ def exhash_result(results:list[dict]) -> str:
     return '\n'.join(out)
 
 
-def exhash(text:str, cmds:list[str]) -> dict:
+def exhash(text:str, cmds:list[str], sw:int=4) -> dict:
     """Verified line-addressed editor. Apply commands to `text`, return a result dict.
 
     Commands primarily use lnhash addresses: ``lineno|hash|cmd`` where hash is
@@ -55,13 +55,15 @@ def exhash(text:str, cmds:list[str]) -> dict:
       j                  Join with next line; with range, joins all
       m dest             Move line(s) after dest address
       t dest             Copy line(s) after dest address
-      >[n]               Indent n levels (default 1, 4 spaces each)
-      <[n]               Dedent n levels (default 1)
+      >[n]               Indent n levels (default 1, `sw` spaces each)
+      <[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)
 
+    `sw` controls shift width for `<` and `>` and defaults to 4.
+
     For a/i/c, remaining lines in the command string are the text block
     (no '.' terminator needed, unlike the CLI).
 
@@ -84,5 +86,5 @@ def exhash(text:str, cmds:list[str]) -> dict:
       "\\n".join(res["lines"])           # "baz\\nbar"
       res = exhash(text, [f"{addr}a\\nnew line 1\\nnew line 2"])
     """
-    r = _exhash(text, *cmds)
+    r = _exhash(text, *cmds, sw=sw)
     return dict(lines=r.lines, hashes=r.hashes, modified=r.modified, deleted=r.deleted)

{exhash-0.2.2 → exhash-0.2.3}/src/bin/exhash.rs

@@ -4,11 +4,11 @@ use std::io::{self, Read};
 use std::path::{Path, PathBuf};
 use std::process;
 
-use exhash::{edit_text, parse_commands_from_args};
+use exhash::{edit_text_with_sw, parse_commands_from_args};
 
 fn usage() {
     eprintln!("\
-Usage: exhash [-h] [--dry-run] [--stdin] <file|-> [commands...]
+Usage: exhash [-h] [--dry-run] [--stdin] [--sw N] <file|-> [commands...]
 
 Verified line-addressed file editor using lnhash addresses.
 
@@ -36,8 +36,8 @@ COMMANDS
   j                  Join with next line; with range, joins all lines in range
   m dest             Move line(s) after dest address
   t dest             Copy line(s) after dest address
-  >[n]               Indent n levels (default 1, 4 spaces each)
-  <[n]               Dedent n levels (default 1)
+  >[n]               Indent n levels (default 1, --sw spaces each)
+  <[n]               Dedent n levels (default 1, --sw spaces each)
   sort               Sort lines alphabetically
   p                  Print (include lines in output without changing them)
   g/pat/cmd          Global: run cmd on matching lines
@@ -50,6 +50,7 @@ TEXT BLOCKS (a/i/c)
 
 OPTIONS
   --dry-run  Don't write; show what would change on stdout
+  --sw N     Shift width for < and > (default 4)
   --stdin    Read input from stdin (file arg must be '-');
              outputs full file in lnhash format.
              Text blocks (a/i/c) not supported in this mode.
@@ -125,6 +126,7 @@ fn main() {
 
     let mut dry_run = false;
     let mut stdin_mode = false;
+    let mut sw = 4usize;
 
     let mut idx = 1;
     while idx < args.len() {
@@ -137,6 +139,20 @@ fn main() {
                 stdin_mode = true;
                 idx += 1;
             }
+            "--sw" => {
+                let Some(val) = args.get(idx + 1) else {
+                    eprintln!("error: --sw requires an integer argument");
+                    process::exit(2);
+                };
+                sw = match val.parse::<usize>() {
+                    Ok(n) => n,
+                    Err(_) => {
+                        eprintln!("error: invalid --sw value {val:?}");
+                        process::exit(2);
+                    }
+                };
+                idx += 2;
+            }
             "--help" | "-h" => {
                 usage();
                 return;
@@ -184,7 +200,7 @@ fn main() {
             }
         };
 
-        let result = match edit_text(&input, &commands) {
+        let result = match edit_text_with_sw(&input, &commands, sw) {
             Ok(r) => r,
             Err(e) => {
                 eprintln!("error: {e}");
@@ -230,7 +246,7 @@ fn main() {
         }
     };
 
-    let result = match edit_text(&text, &commands) {
+    let result = match edit_text_with_sw(&text, &commands, sw) {
         Ok(r) => r,
         Err(e) => {
             eprintln!("error: {e}");

{exhash-0.2.2 → exhash-0.2.3}/src/engine.rs

@@ -30,10 +30,11 @@ struct Line {
 struct Engine {
     lines: Vec<Line>,
     deleted: BTreeSet<usize>,
+    sw: usize,
 }
 
 impl Engine {
-    fn new(input_lines: Vec<String>) -> Self {
+    fn new(input_lines: Vec<String>, sw: usize) -> Self {
         let lines = input_lines
             .into_iter()
             .enumerate()
@@ -47,6 +48,7 @@ impl Engine {
         Self {
             lines,
             deleted: BTreeSet::new(),
+            sw,
         }
     }
 
@@ -490,10 +492,10 @@ impl Engine {
 
     fn indent_range(&mut self, start: usize, end: usize, levels: usize) -> Result<(), EditError> {
         let (s, e) = self.resolve_range(start, end)?;
-        if levels == 0 {
+        if levels == 0 || self.sw == 0 {
             return Ok(());
         }
-        let prefix = "    ".repeat(levels);
+        let prefix = " ".repeat(self.sw * levels);
         for idx in s..=e {
             let new = format!("{}{}", prefix, self.lines[idx].text);
             self.lines[idx].text = new;
@@ -504,12 +506,12 @@ impl Engine {
 
     fn dedent_range(&mut self, start: usize, end: usize, levels: usize) -> Result<(), EditError> {
         let (s, e) = self.resolve_range(start, end)?;
-        if levels == 0 {
+        if levels == 0 || self.sw == 0 {
             return Ok(());
         }
         for idx in s..=e {
             let old = self.lines[idx].text.clone();
-            let new = dedent(&old, levels);
+            let new = dedent(&old, levels, self.sw);
             if new != old {
                 self.lines[idx].text = new;
                 self.lines[idx].modified = true;
@@ -590,9 +592,13 @@ impl Engine {
 /// 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> {
+    edit_text_with_sw(input, commands, 4)
+}
+
+pub fn edit_text_with_sw(input: &str, commands: &[Command], sw: usize) -> Result<EditResult, EditError> {
     let input_lines: Vec<String> = input.lines().map(|l| l.to_string()).collect();
 
-    let mut eng = Engine::new(input_lines);
+    let mut eng = Engine::new(input_lines, sw);
     for c in commands {
         eng.verify_command(c)?;
         eng.apply_command(c)?;
@@ -634,6 +640,7 @@ fn build_regex(pattern: &str, case_insensitive: bool) -> Result<Regex, EditError
 }
 
 fn join_strings(a: &str, b: &str) -> String {
+    let b = b.trim_start_matches(char::is_whitespace);
     if a.is_empty() {
         return b.to_string();
     }
@@ -641,29 +648,27 @@ fn join_strings(a: &str, b: &str) -> String {
         return a.to_string();
     }
     let a_end_ws = a.chars().last().map(|c| c.is_whitespace()).unwrap_or(false);
-    let b_start_ws = b.chars().next().map(|c| c.is_whitespace()).unwrap_or(false);
-    if a_end_ws || b_start_ws {
+    if a_end_ws {
         format!("{a}{b}")
     } else {
         format!("{a} {b}")
     }
 }
 
-fn dedent(line: &str, levels: usize) -> String {
+fn dedent(line: &str, levels: usize, sw: usize) -> String {
     let mut s = line.to_string();
+    if sw == 0 {
+        return s;
+    }
     for _ in 0..levels {
-        if s.starts_with("    ") {
-            s = s[4..].to_string();
-            continue;
-        }
         if s.starts_with('\t') {
             s = s[1..].to_string();
             continue;
         }
-        // Remove up to 4 leading spaces as one level.
+        // Remove up to `sw` leading spaces as one level.
         let mut removed = 0usize;
         let bytes = s.as_bytes();
-        while removed < 4 && removed < bytes.len() && bytes[removed] == b' ' {
+        while removed < sw && removed < bytes.len() && bytes[removed] == b' ' {
             removed += 1;
         }
         if removed > 0 {
@@ -755,6 +760,15 @@ mod tests {
         assert_eq!(res.deleted, vec![2]);
     }
 
+    #[test]
+    fn join_single_address_collapses_indented_next_line_to_single_space() {
+        let input = "hello\n    world\n";
+        let cmd = format!("{}j", addr(1, "hello"));
+        let cmds = parse_commands_from_script(&cmd).unwrap();
+        let res = edit_text(input, &cmds).unwrap();
+        assert_eq!(res.lines, vec!["hello world".to_string()]);
+    }
+
     #[test]
     fn percent_address_joins_whole_file() {
         let input = "a\nb\nc\n";
@@ -854,6 +868,18 @@ mod tests {
         assert_eq!(res.modified, vec![1, 2]);
     }
 
+    #[test]
+    fn indent_and_dedent_with_custom_sw() {
+        let input = "a\n  b\n";
+        let cmd1 = format!("{}>2", addr(1, "a"));
+        let cmd2 = format!("{}<1", addr(2, "  b"));
+        let script = format!("{}\n{}\n", cmd1, cmd2);
+        let cmds = parse_commands_from_script(&script).unwrap();
+        let res = edit_text_with_sw(input, &cmds, 2).unwrap();
+        assert_eq!(res.lines, vec!["    a".to_string(), "b".to_string()]);
+        assert_eq!(res.modified, vec![1, 2]);
+    }
+
     #[test]
     fn sort_range() {
         let input = "c\na\nb\n";
@@ -935,6 +961,17 @@ mod tests {
         assert_eq!(res.modified, vec![1]);
     }
 
+    #[test]
+    fn join_range_preserves_outer_whitespace_and_trims_middle_line_prefixes() {
+        let input = "  alpha\n   beta   \n  gamma  \n";
+        let cmd = format!("{},{}j", addr(1, "  alpha"), addr(3, "  gamma  "));
+        let cmds = parse_commands_from_script(&cmd).unwrap();
+        let res = edit_text(input, &cmds).unwrap();
+        assert_eq!(res.lines, vec!["  alpha beta   gamma  ".to_string()]);
+        assert_eq!(res.deleted, vec![2, 3]);
+        assert_eq!(res.modified, vec![1]);
+    }
+
     #[test]
     fn multi_command_rechecks_hashes_after_each_command() {
         let input = "a\nb\nc\n";

{exhash-0.2.2 → exhash-0.2.3}/src/lib.rs

@@ -10,7 +10,7 @@ mod parse;
 #[cfg(feature = "pyo3")]
 mod python;
 
-pub use engine::{edit_text, EditResult};
+pub use engine::{edit_text, edit_text_with_sw, EditResult};
 pub use lnhash::{format_lnhash, line_hash_u16, parse_lnhash, LnHash};
 pub use parse::{parse_commands_from_args, parse_commands_from_script, parse_commands_from_strs, Address, Command, Subcommand};
 

{exhash-0.2.2 → exhash-0.2.3}/src/python.rs

@@ -36,12 +36,12 @@ fn lnhashview(text: &str) -> Vec<String> {
 }
 
 #[pyfunction]
-#[pyo3(name = "exhash", signature = (text, *cmds))]
-fn py_exhash(text: &str, cmds: Vec<String>) -> PyResult<EditResultPy> {
+#[pyo3(name = "exhash", signature = (text, *cmds, sw=4))]
+fn py_exhash(text: &str, cmds: Vec<String>, sw: usize) -> PyResult<EditResultPy> {
     let cmd_refs: Vec<&str> = cmds.iter().map(|s| s.as_str()).collect();
     let parsed = crate::parse_commands_from_strs(&cmd_refs)
         .map_err(|e| PyValueError::new_err(e.to_string()))?;
-    let res = crate::edit_text(text, &parsed)
+    let res = crate::edit_text_with_sw(text, &parsed, sw)
         .map_err(|e| PyValueError::new_err(e.to_string()))?;
     Ok(res.into())
 }

{exhash-0.2.2 → exhash-0.2.3}/tests/cli.rs

@@ -129,6 +129,31 @@ fn exhash_dry_run_does_not_write() {
     assert_eq!(read_file(&file), "foo\nbar\n");
 }
 
+#[test]
+fn exhash_custom_sw_option_changes_shift_width() {
+    let dir = mk_temp_dir("exhash_custom_sw");
+    let file = dir.join("f.txt");
+    write_file(&file, "a\n");
+
+    let a1 = format_lnhash(1, "a");
+    let cmd = format!("{a1}>1");
+
+    let bin = env!("CARGO_BIN_EXE_exhash");
+    let out = Command::new(bin)
+        .arg("--sw")
+        .arg("2")
+        .arg(&file)
+        .arg(cmd)
+        .output()
+        .unwrap();
+    assert!(out.status.success());
+
+    let stdout = String::from_utf8(out.stdout).unwrap();
+    let expected = format!("{}    a\n", format_lnhash(1, "  a"));
+    assert_eq!(stdout, expected);
+    assert_eq!(read_file(&file), "  a\n");
+}
+
 #[test]
 fn exhash_rejects_stale_lnhash_and_leaves_file_unchanged() {
     let dir = mk_temp_dir("exhash_stale");

{exhash-0.2.2 → exhash-0.2.3}/tests/test_exhash.py

@@ -105,6 +105,13 @@ def test_exhash_move_destination_can_use_last_line():
     assert res["lines"] == ["b", "c", "a"]
     assert res["modified"] == [3]
 
+def test_exhash_custom_sw():
+    text = "a\n"
+    a1 = lnhash(1, "a")
+    res = exhash(text, [f"{a1}>1"], sw=2)
+    assert res["lines"] == ["  a"]
+    assert res["modified"] == [1]
+
 def test_exhash_append():
     text = "a\nb\n"
     addr = lnhash(1, "a")