fixes #9

Author: jph00

python/exhash/__init__.py

@@ -11,14 +11,14 @@ def lnhash(lineno:int, line:str) -> str:
     return _lnhash(lineno, line)
 
 
-def lnhashview(text:str) -> list[str]:
-    'Return lines formatted as ``lineno|hash|  content`` for each line in ``text``.'
-    return _lnhashview(text)
+def lnhashview(text:str, start:int=None, end:int=None) -> list[str]:
+    'Return lines formatted as ``lineno|hash|  content``. Optional 1-based ``start``/``end`` filter the range.'
+    return _lnhashview(text, start, end)
 
 
-def lnhashview_file(path:str) -> list[str]:
-    'Return lines formatted as ``lineno|hash|  content`` for each line in file at ``path``.'
-    return _lnhashview(Path(path).read_text())
+def lnhashview_file(path:str, start:int=None, end:int=None) -> list[str]:
+    'Return lines formatted as ``lineno|hash|  content`` for file at ``path``. Optional 1-based ``start``/``end`` filter the range.'
+    return _lnhashview(Path(path).read_text(), start, end)
 
 
 def exhash_result(results:list[dict]) -> str:

src/bin/lnhashview.rs

@@ -2,7 +2,7 @@ use std::env;
 use std::fs;
 use std::process;
 
-use exhash::format_lnhash;
+use exhash::lnhashview;
 
 fn usage() {
     eprintln!(
@@ -73,42 +73,24 @@ fn main() {
         return;
     }
 
-    let (start_line, end_line) = match (start, end) {
-        (None, None) => (1, lines.len()),
-        (Some(s), None) => (s, s),
-        (Some(s), Some(e)) => (s, e),
+    // When only start is given, CLI shows just that one line
+    let (start, end) = match (start, end) {
+        (Some(s), None) => (Some(s), Some(s)),
         (None, Some(_)) => {
             eprintln!("error: end_line requires start_line");
             process::exit(2);
         }
+        other => other,
     };
 
-    if start_line == 0 {
-        eprintln!("error: start_line is 1-based (must be >= 1)");
-        process::exit(2);
-    }
-
-    if end_line < start_line {
-        eprintln!("error: end_line must be >= start_line");
-        process::exit(2);
-    }
-
-    if end_line > lines.len() {
-        eprintln!(
-            "error: end_line {end_line} is beyond EOF (file has {} line(s))",
-            lines.len()
-        );
-        process::exit(2);
-    }
-
-    for (idx, line) in lines
-        .iter()
-        .enumerate()
-        .skip(start_line - 1)
-        .take(end_line - start_line + 1)
-    {
-        let lineno = idx + 1;
-        let lnh = format_lnhash(lineno, line);
-        println!("{lnh}  {line}");
+    let result = match lnhashview(&lines, start, end) {
+        Ok(r) => r,
+        Err(e) => {
+            eprintln!("error: {e}");
+            process::exit(2);
+        }
+    };
+    for line in result {
+        println!("{line}");
     }
 }

src/lib.rs

@@ -11,7 +11,7 @@ mod parse;
 mod python;
 
 pub use engine::{edit_text, edit_text_with_sw, EditResult};
-pub use lnhash::{format_lnhash, line_hash_u16, parse_lnhash, LnHash};
+pub use lnhash::{format_lnhash, line_hash_u16, lnhashview, parse_lnhash, LnHash};
 pub use parse::{parse_commands_from_args, parse_commands_from_script, parse_commands_from_strs, Address, Command, Subcommand};
 
 #[derive(Debug, Clone)]

src/lnhash.rs

@@ -25,6 +25,24 @@ pub fn format_lnhash(lineno: usize, line: &str) -> String {
     format!("{}|{:04x}|", lineno, line_hash_u16(line))
 }
 
+/// Format lines as `lineno|hash|  content` for a range of lines.
+/// `start` and `end` are 1-based inclusive. Pass `None` for defaults (1 and len).
+/// Returns an error if start is 0, end < start, or end > number of lines.
+pub fn lnhashview(lines: &[&str], start: Option<usize>, end: Option<usize>) -> Result<Vec<String>, EditError> {
+    if lines.is_empty() { return Ok(vec![]); }
+    let s = start.unwrap_or(1);
+    let e = end.unwrap_or(lines.len());
+    if s == 0 { return Err(EditError::new("start_line is 1-based (must be >= 1)")); }
+    if e < s { return Err(EditError::new("end_line must be >= start_line")); }
+    if e > lines.len() {
+        return Err(EditError::new(format!("end_line {} is beyond EOF (file has {} line(s))", e, lines.len())));
+    }
+    Ok(lines.iter().enumerate()
+        .skip(s - 1).take(e - s + 1)
+        .map(|(i, l)| format!("{}  {}", format_lnhash(i + 1, l), l))
+        .collect())
+}
+
 /// Parse a `lineno|hash|` address.
 pub fn parse_lnhash(s: &str) -> Result<LnHash, EditError> {
     let (lh, rest) = parse_lnhash_prefix(s)?;

src/python.rs

@@ -28,11 +28,11 @@ fn line_hash(line: &str) -> String { format!("{:04x}", crate::line_hash_u16(line
 fn lnhash(lineno: usize, line: &str) -> String { crate::format_lnhash(lineno, line) }
 
 #[pyfunction]
-fn lnhashview(text: &str) -> Vec<String> {
-    text.lines()
-        .enumerate()
-        .map(|(i, l)| format!("{}  {}", crate::format_lnhash(i + 1, l), l))
-        .collect()
+#[pyo3(signature = (text, start=None, end=None))]
+fn lnhashview(text: &str, start: Option<usize>, end: Option<usize>) -> PyResult<Vec<String>> {
+    let lines: Vec<&str> = text.lines().collect();
+    crate::lnhashview(&lines, start, end)
+        .map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
 #[pyfunction]

tests/test_exhash.py

@@ -235,3 +235,31 @@ def test_exhash_file_inplace_no_change_on_error(tmp_path):
     f.write_text("foo\nbar\n")
     with pytest.raises(ValueError): exhash_file(str(f), ["99|ffff|s/x/y/"], inplace=True)
     assert f.read_text() == "foo\nbar\n"
+
+def test_lnhashview_start_end():
+    lines = lnhashview("a\nb\nc\nd", start=2, end=3)
+    assert len(lines) == 2
+    assert "b" in lines[0]
+    assert "c" in lines[1]
+    assert lines[0].startswith("2|")
+    assert lines[1].startswith("3|")
+
+def test_lnhashview_start_only():
+    lines = lnhashview("a\nb\nc", start=2)
+    assert len(lines) == 2
+    assert lines[0].startswith("2|")
+
+def test_lnhashview_end_only():
+    lines = lnhashview("a\nb\nc", end=2)
+    assert len(lines) == 2
+    assert lines[0].startswith("1|")
+    assert lines[1].startswith("2|")
+
+def test_lnhashview_file_start_end(tmp_path):
+    from exhash import lnhashview_file
+    f = tmp_path / "test.txt"
+    f.write_text("a\nb\nc\nd\n")
+    lines = lnhashview_file(str(f), start=2, end=3)
+    assert len(lines) == 2
+    assert lines[0].startswith("2|")
+    assert lines[1].startswith("3|")