rgapi 0.2.3__tar.gz → 0.2.4__tar.gz

{rgapi-0.2.3 → rgapi-0.2.4}/Cargo.lock

@@ -50,9 +50,9 @@ checksum = "7f8f80099a98041a3d1622845c271458a2d73e688351bf3cb999266764b81d48"
 
 [[package]]
 name = "crc32fast"
-version = "1.5.3"
+version = "1.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ba106e844045ddc02c20768ac4b0b7cb45f2cc2ecbd833ac9f5dacb183c2055"
+checksum = "5f97d3416d5337d15c4b0d78c8c91df922ca143f57ec20e2d1c188333047ef04"
 dependencies = [
  "cfg-if",
 ]
@@ -84,9 +84,9 @@ checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.42"
+version = "0.8.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e985e0451871ad22fb8d2b6b076e2028a502a0d3950998c2c5c0a4f9b5d9679"
+checksum = "89253175e704ab869b04f9db224d38630e0211a53841a79181deae0889e169f5"
 dependencies = [
  "cfg-if",
  "core_detect",
@@ -118,9 +118,9 @@ dependencies = [
 
 [[package]]
 name = "globset"
-version = "0.4.20"
+version = "0.4.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07c34a9410465b45bd9787443bc7370f37735bad04b0f0cd57ff1a3186c98988"
+checksum = "f98b0d85522dc0a824cfebbc9594ff4a9b289c568bea0370319dfbdf20ccdd2d"
 dependencies = [
  "aho-corasick",
  "bstr",
@@ -161,9 +161,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "ignore"
-version = "0.4.33"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b69833ed729dc5aa7d19541d96d6cf8e9137194207a04916d658e43168402f"
+checksum = "484be5657551d7868d67587df967fb4fcbe9d266a761cc855aaa148fda0b3cc7"
 dependencies = [
  "crossbeam-deque",
  "globset",
@@ -189,9 +189,9 @@ checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
 
 [[package]]
 name = "log"
-version = "0.4.34"
+version = "0.4.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
+checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c"
 
 [[package]]
 name = "memchr"
@@ -320,7 +320,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "crc32fast",
  "fancy-regex",
@@ -335,7 +335,7 @@ dependencies = [
 
 [[package]]
 name = "rgapi-py"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "grep-matcher",
  "pyo3",

{rgapi-0.2.3 → rgapi-0.2.4}/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["py"]
 
 [workspace.package]
-version = "0.2.3"
+version = "0.2.4"
 edition = "2024"
 
 [workspace.dependencies]

{rgapi-0.2.3 → rgapi-0.2.4}/DEV.md

@@ -43,6 +43,8 @@ All user-supplied regexes use the shared `RegexMatcher` in `src/matcher.rs`, bac
 
 The matcher centralizes smart-case analysis and line-ending policy. Line-safe patterns can search a whole buffer; patterns that can consume line endings, inspect neighbouring lines or need the backtracking engine are evaluated on individual lines, so that engine's step budget covers one line, not a whole buffer. Notebook multiline matching instead uses the whole cell. Filename/path regexes match their whole input. Backtracking-limit errors propagate through the existing result channels, including directory-pruning errors; cancellation must not hide a queued error from async consumers.
 
+A walk error, a file the walk can't read, or a notebook `nbrg` can't parse is a skipped error (`RgApiError::is_skipped`). `send_error` sends a skipped error without ending the walk. Any other error ends it. The Python bindings issue a `RuntimeWarning` for each skipped error and raise `ValueError` for any other (`skip_or_raise`, and `worker_error` on async worker threads). Rust's collecting functions, such as `find`, `rg`, `nb_search` and `StreamIter::collect_timeout`, return the first error of either kind. `entry_err` drops a permission error silently at the `max_depth` cap, where the walker opens a directory it never descends into.
+
 Python discovery and `paths=True` results contain absolute `pathlib.Path` objects. Structured search rows hold base-relative string labels with `/` separators. Traversal uses `ignore::WalkParallel`, so result order is not part of the API contract. Search results are structured rows; collected result lists use rg-style `str()` and notebook display. `SearchLine.lnhash` is computed with the same CRC-32-based line-content hash format as exhash (`lineno|hash|`, low 12 bits of CRC-32 over the line's UTF-8 bytes, encoded as two Base64url characters); `lnhashs=True` only changes row display, not `line_number` or matching behavior. Path regexes filter returned/searched paths; `skip_dir` and `skip_dir_re` prune traversal through `ignore::WalkBuilder::filter_entry`. Depth, size, filesystem, hidden, and ignore options use `ignore::WalkBuilder` settings. The `ignore` walker follows every root it is given. Discovery checks each root with `symlink_metadata`. The worker sends each unfollowed link root as a result before walking the other roots. This also supports dangling roots, which the underlying walker would reject. `ls` sets `walk_root_links`, which gives a root link to a directory to the walker. The walker then reports paths under the link. Other discovery roots use absolute paths without canonicalizing. Content searches retain canonical root resolution. `rg_iter` exposes the same parallel search stream that `rg` collects by default; `paths=True` and `count=True` consume that stream with different reducers. Text search skips binary files and invalid UTF-8 content.
 
 Streaming engine: `walk.rs` owns the generic machinery. `StreamIter<T>` is the worker-thread-plus-bounded-channel iterator (`sync_channel(8192)`, so producers block rather than buffer without limit when a consumer lags), and `spawn_walk` owns the shared scaffold: walker config, panic catching, cancel flag, and worker thread. `rg_iter` (`T = SearchLine`), `block_iter` (`T = SearchBlock`), `nb_iter` (`T = NbCell`), and `find_iter` (`T = PathBuf`, the path walk) plug entry closures into that engine. Block search reads each file once, searches it once, groups nonblank lines into blocks, maps matching lines to their blocks, and expands context by block index. Each `SearchBlock` carries numeric boundaries plus hashes for its first and last source lines. Python keeps both and chooses the displayed address without another file read.

{rgapi-0.2.3 → rgapi-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.2.3
+Version: 0.2.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore>=2.2.29
@@ -85,6 +85,8 @@ Discovery uses the `ignore` crate with ripgrep's default filters. It reads `.git
 
 Hidden files are skipped unless `hidden=True`. Discovery returns symlinks themselves, including explicitly named roots and dangling links. Set `follow_links=True` to traverse their targets. Paths retain the symlink spelling. Use `same_file_system=True` to avoid crossing filesystem boundaries.
 
+A walk skips each directory or file that it can't read, such as one without read permission, and issues a `RuntimeWarning` that names it. The rest of the walk continues, as ripgrep's does.
+
 Traversal runs in parallel without guaranteed result order. Use `sorted(...)` when order matters.
 
 `fd` takes `pattern` first and `root` second, as `rg` does. With no pattern, it returns every file under `root`. `pattern` is a smart-case regex matched against each basename. Lowercase patterns match case-insensitively. A pattern containing uppercase letters is case-sensitive. Use `path_re` to match the slash-separated relative path instead.
@@ -235,7 +237,7 @@ A matching cell's display starts at its first matched line. Earlier lines are re
 - `count=True` returns the number of matching cells.
 - `timeout_ms` applies a deadline with the same `stop_reason` values as `rg`.
 
-The parser reads only each cell's `id`, `cell_type`, and `source`. It skips outputs and metadata without loading embedded images or plots. `search_nb(pattern, path, ...)` searches a single notebook file in the same way.
+The parser reads only each cell's `id`, `cell_type`, and `source`. It skips outputs and metadata without loading embedded images or plots. `search_nb(pattern, path, ...)` searches a single notebook file in the same way. `nbrg` skips a `.ipynb` file that isn't valid JSON and issues a `RuntimeWarning` naming the file and the parse error. `search_nb` raises `ValueError` for such a file.
 
 `rgapi-nbrg` exposes notebook search without requiring a Python kernel:
 

{rgapi-0.2.3 → rgapi-0.2.4}/README.md

@@ -64,6 +64,8 @@ Discovery uses the `ignore` crate with ripgrep's default filters. It reads `.git
 
 Hidden files are skipped unless `hidden=True`. Discovery returns symlinks themselves, including explicitly named roots and dangling links. Set `follow_links=True` to traverse their targets. Paths retain the symlink spelling. Use `same_file_system=True` to avoid crossing filesystem boundaries.
 
+A walk skips each directory or file that it can't read, such as one without read permission, and issues a `RuntimeWarning` that names it. The rest of the walk continues, as ripgrep's does.
+
 Traversal runs in parallel without guaranteed result order. Use `sorted(...)` when order matters.
 
 `fd` takes `pattern` first and `root` second, as `rg` does. With no pattern, it returns every file under `root`. `pattern` is a smart-case regex matched against each basename. Lowercase patterns match case-insensitively. A pattern containing uppercase letters is case-sensitive. Use `path_re` to match the slash-separated relative path instead.
@@ -214,7 +216,7 @@ A matching cell's display starts at its first matched line. Earlier lines are re
 - `count=True` returns the number of matching cells.
 - `timeout_ms` applies a deadline with the same `stop_reason` values as `rg`.
 
-The parser reads only each cell's `id`, `cell_type`, and `source`. It skips outputs and metadata without loading embedded images or plots. `search_nb(pattern, path, ...)` searches a single notebook file in the same way.
+The parser reads only each cell's `id`, `cell_type`, and `source`. It skips outputs and metadata without loading embedded images or plots. `search_nb(pattern, path, ...)` searches a single notebook file in the same way. `nbrg` skips a `.ipynb` file that isn't valid JSON and issues a `RuntimeWarning` naming the file and the parse error. `search_nb` raises `ValueError` for such a file.
 
 `rgapi-nbrg` exposes notebook search without requiring a Python kernel:
 

{rgapi-0.2.3 → rgapi-0.2.4}/py/src/lib.rs

@@ -3,14 +3,15 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::RecvTimeoutError;
+use std::thread;
 use std::time::{Duration, Instant};
 
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyRuntimeWarning, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict};
 
 use rgapi::{
-    FindIter, FindOptions, NbCell, NbIter, NbOptions, RgIter, RgOptions, SearchBlock, SearchLine, StreamIter, WalkOptions as WalkOptionsCore,
+    FindIter, FindOptions, NbCell, NbIter, NbOptions, RgApiError, RgIter, RgOptions, SearchBlock, SearchLine, StreamIter, WalkOptions as WalkOptionsCore,
     block_iter as block_iter_core, compile_regex, find, find_iter as find_iter_core, find_iter_with, nb_iter as nb_iter_core, nb_search_file, resolve_roots,
     rg_iter as rg_iter_core, search_path as search_path_core, search_text as search_text_core, spans_for,
 };
@@ -105,14 +106,26 @@ fn check_signals_or_cancel<T>(py: Python<'_>, iter: &StreamIter<T>) -> PyResult<
     Ok(())
 }
 
+/// Warn about a path that a walk skipped because it couldn't read it, as ripgrep reports such a path. Any other error raises `ValueError`.
+fn skip_or_raise(py: Python<'_>, err: RgApiError) -> PyResult<()> {
+    if !err.is_skipped() { return Err(PyValueError::new_err(err.to_string())); }
+    PyErr::warn(py, py.get_type::<PyRuntimeWarning>().as_any(), &std::ffi::CString::new(err.to_string())?, 1)
+}
+
+/// `skip_or_raise` on a worker thread. Gives the message of an error that ends the stream, or `None` when the walk only skipped a path.
+fn worker_error(err: RgApiError) -> Option<String> {
+    if !err.is_skipped() { return Some(err.to_string()); }
+    Python::attach(|py| skip_or_raise(py, err).err().map(|e| e.to_string()))
+}
+
 fn next_stream_py<T: Send>(py: Python<'_>, iter: &mut StreamIter<T>) -> PyResult<Option<T>> {
     loop {
         check_signals_or_cancel(py, iter)?;
         let res = py.detach(|| iter.next_timeout(Duration::from_millis(50)));
         check_signals_or_cancel(py, iter)?;
         match res {
-            Ok(Ok(line)) => return Ok(Some(line)), Ok(Err(err)) => return Err(PyValueError::new_err(err.to_string())),
-            Err(RecvTimeoutError::Disconnected) => return Ok(None), Err(RecvTimeoutError::Timeout) => continue
+            Ok(Ok(line)) => return Ok(Some(line)), Ok(Err(err)) => skip_or_raise(py, err)?, Err(RecvTimeoutError::Disconnected) => return Ok(None),
+            Err(RecvTimeoutError::Timeout) => continue
         }
     }
 }
@@ -131,8 +144,8 @@ fn collect_stream_py<T: Send, P>(py: Python<'_>, mut iter: StreamIter<T>, conv:
         let next = py.detach(|| iter.next_timeout(wait));
         check_signals_or_cancel(py, &iter)?;
         match next {
-            Ok(Ok(line)) => res.push(conv(line)), Ok(Err(err)) => return Err(PyValueError::new_err(err.to_string())),
-            Err(RecvTimeoutError::Disconnected) => return Ok((res, false)), Err(RecvTimeoutError::Timeout) => {}
+            Ok(Ok(line)) => res.push(conv(line)), Ok(Err(err)) => skip_or_raise(py, err)?, Err(RecvTimeoutError::Disconnected) => return Ok((res, false)),
+            Err(RecvTimeoutError::Timeout) => {}
         }
     }
 }
@@ -278,9 +291,11 @@ fn drain_stream<T>(iter: &mut StreamIter<T>, flag: &Arc<AtomicBool>, deadline: O
         match iter.next_timeout(wait) {
             Ok(Ok(line)) => rows.push(line),
             Ok(Err(e)) => {
-                err = Some(e.to_string());
-                iter.cancel();
-                break;
+                if let Some(e) = worker_error(e) {
+                    err = Some(e);
+                    iter.cancel();
+                    break;
+                }
             }
             Err(RecvTimeoutError::Disconnected) => break,
             Err(RecvTimeoutError::Timeout) => {}
@@ -293,7 +308,7 @@ fn stream_async<T, C>(cb: Py<PyAny>, mut iter: StreamIter<T>, deadline: Option<I
     C: Fn(Python<'_>, Vec<T>, bool) -> PyResult<Py<PyAny>> + Send + 'static {
     let cancel = iter.cancel_flag();
     let flag = cancel.clone();
-    std::thread::spawn(move || {
+    thread::spawn(move || {
         let (rows, timed_out, err) = drain_stream(&mut iter, &flag, deadline);
         drop(iter);
         Python::attach(|py| {
@@ -312,18 +327,18 @@ fn stream_iter_async<T, C>(cb: Py<PyAny>, mut iter: StreamIter<T>, batch_max: us
     C: Fn(Python<'_>, Vec<T>) -> PyResult<Py<PyAny>> + Send + 'static {
     let cancel = iter.cancel_flag();
     let flag = cancel.clone();
-    std::thread::spawn(move || {
+    thread::spawn(move || {
         let mut err: Option<String> = None;
         loop {
             if flag.load(Ordering::Relaxed) { break; }
             let first = match iter.next_timeout(Duration::from_millis(50)) {
-                Ok(Ok(line)) => line, Ok(Err(e)) => { err = Some(e.to_string()); break; } Err(RecvTimeoutError::Disconnected) => break,
-                Err(RecvTimeoutError::Timeout) => continue
+                Ok(Ok(line)) => line, Ok(Err(e)) => match worker_error(e) { Some(e) => { err = Some(e); break; } None => continue },
+                Err(RecvTimeoutError::Disconnected) => break, Err(RecvTimeoutError::Timeout) => continue
             };
             let mut batch = vec![first];
             while batch.len() < batch_max {
                 match iter.next_timeout(Duration::ZERO) {
-                    Ok(Ok(line)) => batch.push(line), Ok(Err(e)) => { err = Some(e.to_string()); break; } Err(_) => break
+                    Ok(Ok(line)) => batch.push(line), Ok(Err(e)) => { if let Some(e) = worker_error(e) { err = Some(e); break; } } Err(_) => break
                 }
             }
             let failed = Python::attach(|py| match conv(py, batch) { Ok(res) => cb.call1(py, (res, None::<String>)).is_err(), Err(_) => true });

{rgapi-0.2.3 → rgapi-0.2.4}/python/rgapi/skill.py

@@ -1,6 +1,6 @@
 """Find files, search text, and search notebook cell sources from Python with ripgrep semantics and structured results. Use for fd-style discovery, regex searches, and notebook searches returning stable cell IDs rather than escaped JSON.
 
-Built on ripgrep's `ignore` and `grep-searcher` crates with pure-Rust `fancy-regex`: ignore files, hidden files, globs and extensions follow ripgrep conventions. All regex parameters support backreferences and lookaround without an engine flag. Content matching is line-local unless `nbrg(multiline=True)` is used; filename/path regexes match their full input. Regex compilation or backtracking-limit failures raise `ValueError`; cancellation cannot interrupt an in-progress regex evaluation. Prefer these to shell parsing or manual file scans: `fd`/`ls` for listings, `rg` for files, `nbrg` for notebook cells, `rgstr` for text already in hand.
+Built on ripgrep's `ignore` and `grep-searcher` crates with pure-Rust `fancy-regex`: ignore files, hidden files, globs and extensions follow ripgrep conventions. All regex parameters support backreferences and lookaround without an engine flag. Content matching is line-local unless `nbrg(multiline=True)` is used; filename/path regexes match their full input. Regex compilation or backtracking-limit failures raise `ValueError`; cancellation cannot interrupt an in-progress regex evaluation. A walk skips each directory or file that it can't read, and each notebook that `nbrg` can't parse. Each skip issues a `RuntimeWarning` that names the path. Prefer these to shell parsing or manual file scans: `fd`/`ls` for listings, `rg` for files, `nbrg` for notebook cells, `rgstr` for text already in hand.
 
 Orient with `rg(summary=True)`: one row per block (a paragraph of prose/config) with boundary addresses, where line results show fragments that may need another view. Switch to line results where needed; add `lnhashs=True` when edits may follow. Display results bare; narrow oversized results with parameters, not by joining, slicing, or reformatting.
 

{rgapi-0.2.3 → rgapi-0.2.4}/src/block.rs

@@ -1,15 +1,16 @@
 use std::collections::{BTreeMap, HashMap};
+use std::fs;
 use std::path::Path;
+use std::str;
 use std::sync::Arc;
 use std::sync::atomic::Ordering;
 
 use crate::RegexMatcher;
 use ignore::{DirEntry, WalkState};
 
-use crate::RgApiError;
-use crate::compile_regex;
 use crate::search::{RgOptions, SearchLine, format_lnhash, search_text};
-use crate::walk::{PathFilters, StreamIter, entry_err, rel_path, resolve_roots, spawn_walk};
+use crate::walk::{PathFilters, StreamIter, entry_err, rel_path, resolve_roots, send_error, spawn_walk};
+use crate::{RgApiError, compile_regex};
 
 /// One blank-line-delimited block containing a match, or context for one.
 pub struct SearchBlock {
@@ -48,7 +49,7 @@ fn split_blocks(text: &str) -> Vec<BlockInfo> {
 
 fn process_file(disp: String, bytes: &[u8], matcher: &RegexMatcher, before_context: usize, after_context: usize) -> Result<Vec<SearchBlock>, RgApiError> {
     if bytes.contains(&0) { return Ok(Vec::new()); }
-    let text = match std::str::from_utf8(bytes) { Ok(text) => text, Err(_) => return Ok(Vec::new()) };
+    let text = match str::from_utf8(bytes) { Ok(text) => text, Err(_) => return Ok(Vec::new()) };
     let blocks = split_blocks(text);
     let hits = search_text(disp.clone(), text, matcher.clone(), 0, 0, false)?;
     if hits.is_empty() { return Ok(Vec::new()); }
@@ -83,7 +84,7 @@ fn block_entry(
     if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(base, path);
     if !filters.path_allowed(Path::new(&rel))? { return Ok(Vec::new()); }
-    let bytes = match std::fs::read(path) { Ok(bytes) => bytes, Err(_) => return Ok(Vec::new()) };
+    let bytes = fs::read(path).map_err(|err| RgApiError::unreadable(path, err))?;
     process_file(rel, &bytes, matcher, before_context, after_context)
 }
 
@@ -100,7 +101,7 @@ pub fn block_iter(opts: &RgOptions) -> Result<BlockIter, RgApiError> {
                 for block in blocks { if cancel.load(Ordering::Relaxed) || tx.send(Ok(block)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
             }
-            Err(err) => { let _ = tx.send(Err(err)); WalkState::Quit }
+            Err(err) => send_error(tx, err),
         }
     }))
 }

rgapi-0.2.4/src/lib.rs

@@ -0,0 +1,32 @@
+//! rgapi - Python-friendly wrappers around ripgrep's walking and searching crates.
+
+use std::fmt::Display;
+mod block;
+mod matcher;
+mod nb;
+mod search;
+mod walk;
+
+pub use block::{BlockIter, SearchBlock, block_iter};
+pub use matcher::{RegexMatcher, compile_regex};
+pub use nb::{CellRefs, NbCell, NbIter, NbOptions, ancestor_indices, cell_refs, heading_level, nb_iter, nb_search, nb_search_file, section_range};
+pub use search::{MatchSpan, RgIter, RgOptions, SearchError, SearchKind, SearchLine, rg, rg_iter, search_path, search_text, spans_for};
+pub use walk::{FindIter, FindOptions, StreamIter, WalkOptions, find, find_iter, find_iter_with, resolve_roots};
+
+/// An rgapi failure. `is_skipped` marks an error naming one path that a walk couldn't read, such as a directory without read permission.
+/// The walk sends that error and continues, as ripgrep does. Rust's collecting functions, such as `find`, return the first error of either kind.
+#[derive(Debug, Clone)]
+pub struct RgApiError { msg: String, skipped: bool }
+
+impl RgApiError {
+    pub(crate) fn new(msg: impl Into<String>) -> Self { Self { msg: msg.into(), skipped: false } }
+    pub(crate) fn skipped(msg: impl Display) -> Self { Self { msg: msg.to_string(), skipped: true } }
+    pub(crate) fn unreadable(path: &std::path::Path, err: impl Display) -> Self { Self::skipped(format!("{}: {err}", path.display())) }
+    pub fn is_skipped(&self) -> bool { self.skipped }
+}
+
+impl Display for RgApiError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.msg) } }
+
+impl std::error::Error for RgApiError {}
+
+impl From<std::io::Error> for RgApiError { fn from(err: std::io::Error) -> Self { Self::new(err.to_string()) } }

{rgapi-0.2.3 → rgapi-0.2.4}/src/matcher.rs

@@ -1,6 +1,8 @@
+use ast::ClassSetItem;
 use fancy_regex::{Assertion, Expr, Regex, RegexBuilder};
 use grep_matcher::{LineTerminator, Match, Matcher, NoCaptures};
 use regex_syntax::{ast::{self, Ast, Visitor}, hir::{Class, Hir, HirKind}};
+use std::fmt::Display;
 
 use crate::RgApiError;
 
@@ -68,7 +70,7 @@ pub fn compile_regex(pattern: &str, case_sensitive: Option<bool>, smart_case: bo
     RegexMatcher::build(pattern, case_sensitive, smart_case, !multiline, true)
 }
 
-fn regex_error(error: impl std::fmt::Display) -> RgApiError { RgApiError::new(error.to_string()) }
+fn regex_error(error: impl Display) -> RgApiError { RgApiError::new(error.to_string()) }
 
 impl Matcher for RegexMatcher {
     type Captures = NoCaptures;
@@ -160,10 +162,10 @@ impl Visitor for ClassLiterals {
     type Err = std::convert::Infallible;
     fn finish(self) -> Result<Self, Self::Err> { Ok(self) }
     fn visit_pre(&mut self, ast: &Ast) -> Result<(), Self::Err> { if let Ast::Literal(lit) = ast { self.add(lit.c); } Ok(()) }
-    fn visit_class_set_item_pre(&mut self, item: &ast::ClassSetItem) -> Result<(), Self::Err> {
+    fn visit_class_set_item_pre(&mut self, item: &ClassSetItem) -> Result<(), Self::Err> {
         match item {
-            ast::ClassSetItem::Literal(lit) => self.add(lit.c),
-            ast::ClassSetItem::Range(r) => {
+            ClassSetItem::Literal(lit) => self.add(lit.c),
+            ClassSetItem::Range(r) => {
                 self.add(r.start.c);
                 self.add(r.end.c);
             }

{rgapi-0.2.3 → rgapi-0.2.4}/src/nb.rs

@@ -1,4 +1,6 @@
+use serde_json::Value;
 use std::collections::{BTreeMap, HashMap};
+use std::fs;
 use std::path::Path;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, LazyLock};
@@ -8,10 +10,9 @@ use fancy_regex::Regex;
 use ignore::{DirEntry, WalkState};
 use serde::Deserialize;
 
-use crate::RgApiError;
-use crate::compile_regex;
 use crate::search::{SearchLine, search_text};
-use crate::walk::{PathFilters, StreamIter, WalkOptions, entry_err, rel_path, resolve_roots, spawn_walk};
+use crate::walk::{PathFilters, StreamIter, WalkOptions, entry_err, rel_path, resolve_roots, send_error, spawn_walk};
+use crate::{RgApiError, compile_regex};
 
 static HEADING_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^#{1,6} \w").unwrap());
 
@@ -56,8 +57,8 @@ fn tool_names(text: &str) -> Vec<String> {
 }
 
 /// nbformat multiline text, a string or a list of strings, as one string.
-fn nb_text(v: &serde_json::Value) -> String {
-    match v { serde_json::Value::String(s) => s.clone(), serde_json::Value::Array(a) => a.iter().filter_map(|o| o.as_str()).collect(), _ => String::new() }
+fn nb_text(v: &Value) -> String {
+    match v { Value::String(s) => s.clone(), Value::Array(a) => a.iter().filter_map(|o| o.as_str()).collect(), _ => String::new() }
 }
 
 /// The sigil references in one notebook cell, in order of appearance.
@@ -75,7 +76,7 @@ pub struct CellRefs {
 /// `vars` and `cmds` come from a prompt cell's source. `tools` comes from the source of a prompt or Markdown cell.
 /// For every other cell, `tools` comes from the `text/markdown` data of its `display_data` and `execute_result` outputs.
 /// A prompt cell's outputs are never read.
-pub fn cell_refs(cell: &serde_json::Value) -> CellRefs {
+pub fn cell_refs(cell: &Value) -> CellRefs {
     let src = nb_text(&cell["source"]);
     let prompt = cell["metadata"]["solveit_ai"] == true;
     let mut res = CellRefs::default();
@@ -109,12 +110,10 @@ pub struct NbCell {
 struct RawNb { #[serde(default)] cells: Vec<RawCell> }
 
 #[derive(Deserialize)]
-struct RawCell { #[serde(default)] id: Option<serde_json::Value>, #[serde(default)] cell_type: Option<String>, #[serde(default)] source: Source }
+struct RawCell { #[serde(default)] id: Option<Value>, #[serde(default)] cell_type: Option<String>, #[serde(default)] source: Source }
 
 impl RawCell {
-    fn id_string(&self, index: usize) -> String {
-        match &self.id { Some(serde_json::Value::String(s)) => s.clone(), Some(v) => v.to_string(), None => index.to_string() }
-    }
+    fn id_string(&self, index: usize) -> String { match &self.id { Some(Value::String(s)) => s.clone(), Some(v) => v.to_string(), None => index.to_string() } }
 }
 
 // nbformat `source` is a list of lines or a single string (or absent/null).
@@ -126,9 +125,13 @@ impl Source {
     fn text(&self) -> String { match self { Source::Lines(v) => v.concat(), Source::Text(s) => s.clone(), Source::Empty => String::new() } }
 }
 
-fn process_file(disp: String, bytes: &[u8], matcher: &RegexMatcher, cell_context: usize, multiline: bool) -> Result<Vec<NbCell>, RgApiError> {
-    // Not a parseable notebook (bad JSON, or JSON that isn't a notebook): skip, like a binary file.
-    let nb: RawNb = match serde_json::from_slice(bytes) { Ok(nb) => nb, Err(_) => return Ok(Vec::new()) };
+/// The notebook at `path`. A file that can't be read, or parsed as a notebook, gives a skipped error naming `path`.
+fn notebook(path: &Path) -> Result<RawNb, RgApiError> {
+    let bytes = fs::read(path).map_err(|err| RgApiError::unreadable(path, err))?;
+    serde_json::from_slice(&bytes).map_err(|err| RgApiError::unreadable(path, err))
+}
+
+fn process_file(disp: String, nb: RawNb, matcher: &RegexMatcher, cell_context: usize, multiline: bool) -> Result<Vec<NbCell>, RgApiError> {
     let n = nb.cells.len();
     let mut info = Vec::with_capacity(n);
     let mut matched: Vec<(usize, Vec<SearchLine>)> = Vec::new();
@@ -158,8 +161,7 @@ pub fn nb_search_file(
     path: &Path, display_path: String, pattern: &str, case_sensitive: Option<bool>, smart_case: bool, cell_context: usize, multiline: bool
 ) -> Result<Vec<NbCell>, RgApiError> {
     let matcher = compile_regex(pattern, case_sensitive, smart_case, multiline)?;
-    let bytes = match std::fs::read(path) { Ok(b) => b, Err(_) => return Ok(Vec::new()) };
-    process_file(display_path, &bytes, &matcher, cell_context, multiline)
+    process_file(display_path, notebook(path)?, &matcher, cell_context, multiline)
 }
 
 fn nb_entry(
@@ -171,8 +173,7 @@ fn nb_entry(
     if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(base, path);
     if !filters.path_allowed(Path::new(&rel))? { return Ok(Vec::new()); }
-    let bytes = match std::fs::read(path) { Ok(b) => b, Err(_) => return Ok(Vec::new()) };
-    process_file(rel, &bytes, matcher, cell_context, multiline)
+    process_file(rel, notebook(path)?, matcher, cell_context, multiline)
 }
 
 pub type NbIter = StreamIter<NbCell>;
@@ -188,7 +189,7 @@ pub fn nb_iter(opts: &NbOptions) -> Result<NbIter, RgApiError> {
                 for cell in cells { if cancel.load(Ordering::Relaxed) || tx.send(Ok(cell)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
             }
-            Err(err) => { let _ = tx.send(Err(err)); WalkState::Quit }
+            Err(err) => send_error(tx, err),
         }
     }))
 }

{rgapi-0.2.3 → rgapi-0.2.4}/src/search.rs

@@ -1,4 +1,7 @@
+use grep_searcher::Searcher;
+use std::fmt::Display;
 use std::path::Path;
+use std::str;
 use std::sync::{Arc, atomic::{AtomicBool, Ordering}, mpsc::SyncSender};
 
 use crate::matcher::RegexMatcher;
@@ -6,7 +9,7 @@ use grep_matcher::LineTerminator;
 use grep_searcher::{BinaryDetection, SearcherBuilder, Sink, SinkContext, SinkContextKind, SinkError, SinkMatch};
 use ignore::{DirEntry, WalkState};
 
-use crate::walk::{PathFilters, StreamIter, WalkOptions, entry_err, rel_path, resolve_roots, spawn_walk};
+use crate::walk::{PathFilters, StreamIter, WalkOptions, entry_err, rel_path, resolve_roots, send_error, spawn_walk};
 use crate::{RgApiError, compile_regex};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -46,27 +49,25 @@ fn search_entry(
     max_depth: Option<usize>, tx: &SyncSender<Result<SearchLine, RgApiError>>, cancel: &Arc<AtomicBool>) -> WalkState {
     if is_cancelled(cancel) { return WalkState::Quit; }
     let dent = match entry {
-        Ok(dent) => dent, Err(err) => { return match entry_err(err, max_depth) { Some(e) => send_search_error(tx, e), None => WalkState::Continue }; }
+        Ok(dent) => dent, Err(err) => { return match entry_err(err, max_depth) { Some(e) => send_error(tx, e), None => WalkState::Continue }; }
     };
     let path = dent.path();
     let Some(ft) = dent.file_type() else { return WalkState::Continue; };
     if !ft.is_file() { return WalkState::Continue; }
     let rel = rel_path(base, path);
-    match filters.path_allowed(Path::new(&rel)) { Ok(true) => {} Ok(false) => return WalkState::Continue, Err(err) => return send_search_error(tx, err) }
+    match filters.path_allowed(Path::new(&rel)) { Ok(true) => {} Ok(false) => return WalkState::Continue, Err(err) => return send_error(tx, err) }
     match search_path_cancelable(path, rel, matcher.clone(), before_context, after_context, Some(cancel.clone())) {
         Ok(lines) => {
             if is_cancelled(cancel) { return WalkState::Quit; }
             for line in lines { if is_cancelled(cancel) || tx.send(Ok(line)).is_err() { return WalkState::Quit; } }
             WalkState::Continue
         }
-        Err(err) => send_search_error(tx, err),
+        Err(err) => send_error(tx, err),
     }
 }
 
 fn is_cancelled(cancel: &Arc<AtomicBool>) -> bool { cancel.load(Ordering::Relaxed) }
 
-fn send_search_error(tx: &SyncSender<Result<SearchLine, RgApiError>>, err: RgApiError) -> WalkState { let _ = tx.send(Err(err)); WalkState::Quit }
-
 pub(crate) fn format_lnhash(lineno: u64, line: &str) -> String {
     const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
     let hash = crc32fast::hash(line.as_bytes()) as usize;
@@ -88,7 +89,8 @@ fn search_path_cancelable(
     let mut out = Vec::new();
     let search_matcher = matcher.clone();
     let sink = CollectSink { path: display_path, matcher, lines: &mut out, cancel };
-    match searcher.search_path(search_matcher, path, sink) {
+    let file = std::fs::File::open(path).map_err(|err| RgApiError::unreadable(path, err))?;
+    match searcher.search_file(search_matcher, &file, sink) {
         Ok(()) => Ok(out), Err(SearchError::InvalidUtf8) => Ok(Vec::new()), Err(err) => Err(RgApiError::new(err.to_string()))
     }
 }
@@ -114,7 +116,7 @@ impl CollectSink<'_> { fn cancelled(&self) -> bool { match &self.cancel { Some(c
 impl Sink for CollectSink<'_> {
     type Error = SearchError;
 
-    fn matched(&mut self, _searcher: &grep_searcher::Searcher, mat: &SinkMatch<'_>) -> Result<bool, Self::Error> {
+    fn matched(&mut self, _searcher: &Searcher, mat: &SinkMatch<'_>) -> Result<bool, Self::Error> {
         if self.cancelled() { return Ok(false); }
         let line = bytes_to_line(mat.bytes())?;
         let line_number = mat.line_number().unwrap_or(0);
@@ -124,7 +126,7 @@ impl Sink for CollectSink<'_> {
         Ok(!self.cancelled())
     }
 
-    fn context(&mut self, _searcher: &grep_searcher::Searcher, ctx: &SinkContext<'_>) -> Result<bool, Self::Error> {
+    fn context(&mut self, _searcher: &Searcher, ctx: &SinkContext<'_>) -> Result<bool, Self::Error> {
         if self.cancelled() { return Ok(false); }
         let kind = match ctx.kind() {
             SinkContextKind::Before => SearchKind::Before, SinkContextKind::After => SearchKind::After, SinkContextKind::Other => SearchKind::Context
@@ -134,27 +136,27 @@ impl Sink for CollectSink<'_> {
         self.lines.push(SearchLine { kind, path: self.path.clone(), line_number, lnhash: format_lnhash(line_number, &line), line, matches: Vec::new() });
         Ok(!self.cancelled())
     }
-    fn binary_data(&mut self, _searcher: &grep_searcher::Searcher, _binary_byte_offset: u64) -> Result<bool, Self::Error> { self.lines.clear(); Ok(false) }
+    fn binary_data(&mut self, _searcher: &Searcher, _binary_byte_offset: u64) -> Result<bool, Self::Error> { self.lines.clear(); Ok(false) }
 }
 
 #[derive(Debug)]
 /// A search failure, including invalid UTF-8 in matched text.
 pub enum SearchError { Message(String), InvalidUtf8 }
-impl std::fmt::Display for SearchError {
+impl Display for SearchError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self { Self::Message(msg) => write!(f, "{msg}"), Self::InvalidUtf8 => write!(f, "invalid utf-8") }
     }
 }
 impl std::error::Error for SearchError {}
-impl SinkError for SearchError { fn error_message<T: std::fmt::Display>(message: T) -> Self { Self::Message(message.to_string()) } }
+impl SinkError for SearchError { fn error_message<T: Display>(message: T) -> Self { Self::Message(message.to_string()) } }
 fn bytes_to_line(bytes: &[u8]) -> Result<String, SearchError> {
-    let s = std::str::from_utf8(bytes).map_err(|_| SearchError::InvalidUtf8)?;
+    let s = str::from_utf8(bytes).map_err(|_| SearchError::InvalidUtf8)?;
     Ok(s.trim_end_matches(['\r', '\n']).to_string())
 }
 /// Return byte offsets for every match in a line.
 pub fn spans_for(matcher: &RegexMatcher, bytes: &[u8]) -> Result<Vec<MatchSpan>, SearchError> {
     let mut spans = Vec::new();
-    let text = std::str::from_utf8(bytes).map_err(|_| SearchError::InvalidUtf8)?;
+    let text = str::from_utf8(bytes).map_err(|_| SearchError::InvalidUtf8)?;
     matcher.for_each_match(text, |start, end| spans.push(MatchSpan { start, end })).map_err(|e| SearchError::Message(e.to_string()))?;
     Ok(spans)
 }

{rgapi-0.2.3 → rgapi-0.2.4}/src/walk.rs

@@ -1,8 +1,12 @@
+use mpsc::{RecvTimeoutError, SyncSender};
 use std::collections::HashSet;
 use std::panic::{AssertUnwindSafe, catch_unwind};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, mpsc};
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
 
 use globset::{GlobBuilder, GlobSet, GlobSetBuilder};
 use grep_matcher::Matcher;
@@ -85,12 +89,12 @@ pub fn find_iter_with(opts: &FindOptions, walk_root_links: bool) -> Result<FindI
         if panic_probe { panic!("rgapi: deliberate panic for tests (panic_probe)"); }
         match find_entry(dent, base, filters, pattern.as_ref(), files, dirs, special_files, max_depth) {
             Ok(Some(path)) => { if cancel.load(Ordering::Relaxed) || tx.send(Ok(path)).is_err() { return WalkState::Quit; } WalkState::Continue }
-            Ok(None) => WalkState::Continue, Err(err) => { let _ = tx.send(Err(err)); WalkState::Quit }
+            Ok(None) => WalkState::Continue, Err(err) => send_error(tx, err)
         }
     }))
 }
 
-pub struct StreamIter<T> { rx: mpsc::Receiver<Result<T, RgApiError>>, cancel: Arc<AtomicBool>, worker: Option<std::thread::JoinHandle<()>> }
+pub struct StreamIter<T> { rx: mpsc::Receiver<Result<T, RgApiError>>, cancel: Arc<AtomicBool>, worker: Option<JoinHandle<()>> }
 
 impl<T> StreamIter<T> {
     pub fn cancel(&self) { self.cancel.store(true, Ordering::Relaxed); }
@@ -108,19 +112,19 @@ impl<T> StreamIter<T> {
         Ok(())
     }
 
-    pub fn next_timeout(&mut self, timeout: std::time::Duration) -> Result<Result<T, RgApiError>, mpsc::RecvTimeoutError> { self.rx.recv_timeout(timeout) }
+    pub fn next_timeout(&mut self, timeout: Duration) -> Result<Result<T, RgApiError>, RecvTimeoutError> { self.rx.recv_timeout(timeout) }
 
     /// Collect all items, stopping at `timeout_ms`; the bool is true when the deadline stopped it.
     pub fn collect_timeout(mut self, timeout_ms: Option<u64>) -> Result<(Vec<T>, bool), RgApiError> {
         let Some(ms) = timeout_ms else { return Ok((self.collect::<Result<Vec<_>, _>>()?, false)); };
-        let deadline = std::time::Instant::now() + std::time::Duration::from_millis(ms);
+        let deadline = Instant::now() + Duration::from_millis(ms);
         let mut res = Vec::new();
         loop {
-            let left = deadline.saturating_duration_since(std::time::Instant::now());
+            let left = deadline.saturating_duration_since(Instant::now());
             if left.is_zero() { return Ok((res, true)); }
             match self.next_timeout(left) {
-                Ok(Ok(item)) => res.push(item), Ok(Err(err)) => return Err(err), Err(mpsc::RecvTimeoutError::Disconnected) => return Ok((res, false)),
-                Err(mpsc::RecvTimeoutError::Timeout) => return Ok((res, true))
+                Ok(Ok(item)) => res.push(item), Ok(Err(err)) => return Err(err), Err(RecvTimeoutError::Disconnected) => return Ok((res, false)),
+                Err(RecvTimeoutError::Timeout) => return Ok((res, true))
             }
         }
     }
@@ -136,6 +140,7 @@ impl<T> Drop for StreamIter<T> { fn drop(&mut self) { self.cancel(); } }
 #[cfg(test)]
 mod close_tests {
     use super::*;
+    use std::thread;
 
     #[test]
     fn cancel_and_join_drains_full_channel_and_waits_for_worker() {
@@ -145,7 +150,7 @@ mod close_tests {
         let worker_cancel = cancel.clone();
         let done = Arc::new(AtomicBool::new(false));
         let worker_done = done.clone();
-        let worker = std::thread::spawn(move || {
+        let worker = thread::spawn(move || {
             tx.send(Ok(1)).unwrap();
             started.send(()).unwrap();
             // This blocks while the channel is full; close must drain, not just join.
@@ -161,14 +166,14 @@ mod close_tests {
 }
 
 pub(crate) fn spawn_walk<T, F>(roots: Vec<PathBuf>, base: PathBuf, walk: &WalkOptions, filters: Arc<PathFilters>, ready: Vec<T>, entry: F) -> StreamIter<T>
-where T: Send + 'static, F: Fn(Result<DirEntry, ignore::Error>, &Path, &PathFilters, &mpsc::SyncSender<Result<T, RgApiError>>, &Arc<AtomicBool>) -> WalkState
-        + Send + Sync + Clone + 'static {
+where T: Send + 'static, F: Fn(Result<DirEntry, ignore::Error>, &Path, &PathFilters, &SyncSender<Result<T, RgApiError>>, &Arc<AtomicBool>) -> WalkState + Send
+        + Sync + Clone + 'static {
     let cancel = Arc::new(AtomicBool::new(false));
     let worker_cancel = cancel.clone();
     let (tx, rx) = mpsc::sync_channel(8192);
     let walk = walk.clone();
     let seen = roots.iter().any(|a| roots.iter().any(|b| a != b && a.starts_with(b))).then(|| Arc::new(Mutex::new(HashSet::new())));
-    let worker = std::thread::spawn(move || {
+    let worker = thread::spawn(move || {
         for item in ready { if tx.send(Ok(item)).is_err() { return; } }
         for root in &roots {
             if worker_cancel.load(Ordering::Relaxed) { return; }
@@ -234,11 +239,17 @@ fn file_root_flags(root: &Path, ignore: bool, hidden: bool) -> (bool, bool) { if
 
 // At the max_depth cap the walker opens directories it will never descend into
 // (readdir precedes the depth check in `ignore`), so permission failures there are
-// harmless: skip them (None). Every other walk error is fatal (Some).
+// harmless: skip them silently (None). Report every other walk error as a skipped path (Some).
 pub(crate) fn entry_err(err: ignore::Error, max_depth: Option<usize>) -> Option<RgApiError> {
     let at_cap = max_depth.is_some_and(|m| err.depth().is_some_and(|d| d >= m));
     let denied = err.io_error().is_some_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied);
-    if at_cap && denied { None } else { Some(RgApiError::new(err.to_string())) }
+    if at_cap && denied { None } else { Some(RgApiError::skipped(err)) }
+}
+
+/// Send `err`, then end the walk unless `err` only skipped a path.
+pub(crate) fn send_error<T>(tx: &SyncSender<Result<T, RgApiError>>, err: RgApiError) -> WalkState {
+    let skipped = err.is_skipped();
+    if tx.send(Err(err)).is_ok() && skipped { WalkState::Continue } else { WalkState::Quit }
 }
 
 fn normalize_root(path: &Path) -> Result<PathBuf, RgApiError> {
@@ -287,7 +298,7 @@ fn configure_walker(walker: &mut WalkBuilder, root: &Path, walk: &WalkOptions) {
 }
 
 fn filter_dirs<T: Send + 'static>(
-    walker: &mut WalkBuilder, base: &Path, filters: Arc<PathFilters>, tx: mpsc::SyncSender<Result<T, RgApiError>>, cancel: Arc<AtomicBool>) {
+    walker: &mut WalkBuilder, base: &Path, filters: Arc<PathFilters>, tx: SyncSender<Result<T, RgApiError>>, cancel: Arc<AtomicBool>) {
     let base = base.to_path_buf();
     walker.filter_entry(move |entry| {
         if cancel.load(Ordering::Relaxed) { false } else {
@@ -350,6 +361,8 @@ fn re_match(matcher: &RegexMatcher, rel: &str) -> Result<bool, RgApiError> { mat
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::thread;
+    use std::time::Duration;
 
     #[test]
     fn globs_match_names_or_root_relative_components() {
@@ -366,8 +379,8 @@ mod tests {
     fn iter_of(items: Vec<u32>, delay_ms: u64) -> StreamIter<u32> {
         let (tx, rx) = mpsc::channel();
         let cancel = Arc::new(AtomicBool::new(false));
-        let worker = std::thread::spawn(move || {
-            for i in items { std::thread::sleep(std::time::Duration::from_millis(delay_ms)); if tx.send(Ok(i)).is_err() { return; } }
+        let worker = thread::spawn(move || {
+            for i in items { thread::sleep(Duration::from_millis(delay_ms)); if tx.send(Ok(i)).is_err() { return; } }
         });
         StreamIter { rx, cancel, worker: Some(worker) }
     }

{rgapi-0.2.3 → rgapi-0.2.4}/tests/test_rgapi.py

@@ -371,8 +371,7 @@ def test_backreferences_and_lookaround(tmp_path):
 
 
 def test_line_local_regexes_and_smart_case():
-    for pattern in [r"foo\s+foo", r"foo[^x]+foo", r"(?s:foo.+foo)", r"foo(?=\s+foo)"]:
-        assert rgstr(pattern, "foo\nfoo\n") == []
+    for pattern in [r"foo\s+foo", r"foo[^x]+foo", r"(?s:foo.+foo)", r"foo(?=\s+foo)"]: assert rgstr(pattern, "foo\nfoo\n") == []
     assert [r.matches for r in rgstr(r"(?s:foo.*|bar)", "foo\nbar\n")] == [[(0, 3)], [(0, 3)]]
     assert compile(r"\Afoo\z").finditer("foo\nfoo\n") == [(0, 3), (4, 7)]
     empty = compile(r"\A\z")
@@ -395,7 +394,7 @@ def test_regex_runtime_errors(tmp_path):
     p.mkdir()
     (tmp_path/(text+".txt")).write_text(text)
     for search in [lambda: compile(pattern).is_match(text), lambda: rgstr(pattern, text),
-                   lambda: fd(pattern, tmp_path), lambda: fd(root=tmp_path, path_re=pattern), lambda: fd(root=tmp_path, skip_dir_re=pattern)]:
+        lambda: fd(pattern, tmp_path), lambda: fd(root=tmp_path, path_re=pattern), lambda: fd(root=tmp_path, skip_dir_re=pattern)]:
         with pytest.raises(ValueError, match="backtrack"): search()
 
 
@@ -498,12 +497,13 @@ def test_file_as_root_searches_just_that_file(tmp_path):
     with pytest.raises(Exception): rg("TODO", str(tmp_path / "nope.txt"))
 
 
-def test_nbrg_skips_bad_json(tmp_path):
-    from rgapi import nbrg
+def test_nbrg_warns_on_bad_json(tmp_path):
+    from rgapi import nbrg, search_nb
     write_nb(tmp_path / "good.ipynb", [_cell("code", ["read_csv(x)\n"], cid="g1")])
     (tmp_path / "bad.ipynb").write_text("{not valid json")
-    a = nbrg("read_csv", str(tmp_path))
+    with pytest.warns(RuntimeWarning, match=r"bad\.ipynb: .* at line 1 column"): a = nbrg("read_csv", tmp_path)
     assert {c.cell_id for c in a} == {"g1"}
+    with pytest.raises(ValueError, match=r"bad\.ipynb: "): search_nb("read_csv", tmp_path / "bad.ipynb")
 
 
 def test_search_nb_single_and_asdict_str(tmp_path):
@@ -717,12 +717,41 @@ def test_file_root_ignores_siblings_and_depth_cap_permissions(tmp_path):
         got = sorted({r.path for r in rg("x", tmp_path, max_depth=1, ignore=False, hidden=True)})
         assert got == [".gitignore", ".hid.txt", "f.txt"]                       # depth-cap dir skipped silently
         assert list(fd(root=tmp_path, max_depth=1, ignore=False)) == [f]
-        with pytest.raises(ValueError, match="ermission"):
-            rg("x", tmp_path)                                     # uncapped: unreadable dir in tree is fatal
-        with pytest.raises(ValueError, match="ermission"):
-            rg("x", tmp_path, max_depth=2)                        # cap above the dir: descent needed, fatal
+        with pytest.warns(RuntimeWarning, match="locked: Permission denied"):
+            assert not rg("x", tmp_path, max_depth=2)              # cap above the dir: descent needed, so it's reported
     finally: locked.chmod(0o755)
 
+def test_unreadable_paths_warn_and_walks_continue(tmp_path):
+    from fastcore.aio import run_sync
+    from rgapi import nbrg, rga, rga_iter
+    (tmp_path / "a.txt").write_text("x\n")
+    write_nb(tmp_path / "a.ipynb", [_cell("code", ["x\n"], cid="c1")])
+    secret = tmp_path / "secret.ipynb"
+    write_nb(secret, [_cell("code", ["x\n"], cid="c2")])
+    locked = tmp_path / "locked"
+    locked.mkdir()
+    (locked / "b.txt").write_text("x\n")
+    def walk(f):
+        "`f()`'s results, and the names of the paths it warned it skipped"
+        with pytest.warns(RuntimeWarning) as caught: res = f()
+        return res, sorted(Path(str(w.message).partition(": ")[0]).name for w in caught)
+    async def listed(it): return [r async for r in it]
+    searches = [lambda: rg("x", tmp_path), lambda: list(rg_iter("x", tmp_path)), lambda: run_sync(rga("x", tmp_path)),
+        lambda: run_sync(listed(rga_iter("x", tmp_path))), lambda: rg("x", tmp_path, summary=True)]
+    secret.chmod(0o000)
+    locked.chmod(0o000)
+    try:
+        for search in searches:
+            res, skipped = walk(search)
+            assert sorted({r.path for r in res}) == ["a.ipynb", "a.txt"] and skipped == ["locked", "secret.ipynb"]
+        res, skipped = walk(lambda: nbrg("x", tmp_path))
+        assert [c.cell_id for c in res] == ["c1"] and skipped == ["locked", "secret.ipynb"]
+        res, skipped = walk(lambda: fd(root=tmp_path))                 # discovery reads no files, so only the dir is skipped
+        assert sorted(p.name for p in res) == ["a.ipynb", "a.txt", "secret.ipynb"] and skipped == ["locked"]
+    finally:
+        secret.chmod(0o644)
+        locked.chmod(0o755)
+
 def test_symlink_link_target_and_show_target(tmp_path):
     (tmp_path / "real").mkdir()
     (tmp_path / "f.txt").write_text("x\n")

rgapi-0.2.3/src/lib.rs

@@ -1,24 +0,0 @@
-//! rgapi - Python-friendly wrappers around ripgrep's walking and searching crates.
-
-mod block;
-mod matcher;
-mod nb;
-mod search;
-mod walk;
-
-pub use block::{BlockIter, SearchBlock, block_iter};
-pub use matcher::{RegexMatcher, compile_regex};
-pub use nb::{CellRefs, NbCell, NbIter, NbOptions, ancestor_indices, cell_refs, heading_level, nb_iter, nb_search, nb_search_file, section_range};
-pub use search::{MatchSpan, RgIter, RgOptions, SearchError, SearchKind, SearchLine, rg, rg_iter, search_path, search_text, spans_for};
-pub use walk::{FindIter, FindOptions, StreamIter, WalkOptions, find, find_iter, find_iter_with, resolve_roots};
-
-#[derive(Debug, Clone)]
-pub struct RgApiError { msg: String }
-
-impl RgApiError { pub(crate) fn new(msg: impl Into<String>) -> Self { Self { msg: msg.into() } } }
-
-impl std::fmt::Display for RgApiError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}", self.msg) } }
-
-impl std::error::Error for RgApiError {}
-
-impl From<std::io::Error> for RgApiError { fn from(err: std::io::Error) -> Self { Self::new(err.to_string()) } }