rgapi 0.1.22__tar.gz → 0.1.24__tar.gz

{rgapi-0.1.22 → rgapi-0.1.24}/.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
       - uses: actions/checkout@v7
       - uses: PyO3/maturin-action@v1
         with:
-          args: --release --out dist -i python3.10 -i python3.11 -i python3.12 -i python3.13
+          args: --profile dist --out dist -i python3.10 -i python3.11 -i python3.12 -i python3.13
           manylinux: auto
       - uses: actions/upload-artifact@v7
         with:
@@ -58,6 +58,12 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v7
+      - uses: dtolnay/rust-toolchain@stable
+      - id: crates-auth
+        uses: rust-lang/crates-io-auth-action@v1
+      - run: cargo publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ steps.crates-auth.outputs.token }}
       - uses: actions/download-artifact@v8
         with:
           path: dist

{rgapi-0.1.22 → rgapi-0.1.24}/Cargo.lock

@@ -30,18 +30,18 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "crc32fast"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+checksum = "8498c871161e1742aaa9d52551b2d6ebdd4c3d45a3be423e3728f33b955be550"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.7"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
+checksum = "622f3fc73690be383c7214310406f28a90e6edeadc3cea882f9d71e495b9711a"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -49,18 +49,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.20"
+version = "0.9.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
+checksum = "dc74980687109a3b14c72fd458107bf0baa1da1a1a805e178d15501ba9b86d9d"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.22"
+version = "0.8.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+checksum = "a31eee39dddec8330830986fcd7625edb5a24ec90ea038215273bbc3adb08ac6"
 
 [[package]]
 name = "encoding_rs"
@@ -166,9 +166,9 @@ checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "log"
-version = "0.4.33"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
+checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 
 [[package]]
 name = "memchr"
@@ -291,7 +291,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.1.22"
+version = "0.1.24"
 dependencies = [
  "crc32fast",
  "globset",
@@ -340,7 +340,7 @@ checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 3.0.3",
+ "syn 3.0.5",
 ]
 
 [[package]]
@@ -369,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "3.0.3"
+version = "3.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+checksum = "12df2e0110f65b775f769bb17ef989067a1d931b2eb822bd4346631eeada89f9"
 dependencies = [
  "proc-macro2",
  "quote",

{rgapi-0.1.22 → rgapi-0.1.24}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rgapi"
-version = "0.1.22"
+version = "0.1.24"
 edition = "2024"
 rust-version = "1.91"
 license = "Apache-2.0"
@@ -31,3 +31,20 @@ extension-module = ["python", "pyo3/extension-module"]
 
 [lints.clippy]
 too_many_arguments = "allow"
+
+[profile.release]
+lto = false
+codegen-units = 16
+
+[profile.release.package.rgapi]
+incremental = true
+
+[profile.dist]
+inherits = "release"
+lto = true
+incremental = false
+codegen-units = 1
+strip = true
+
+[profile.dist.package.rgapi]
+incremental = false

{rgapi-0.1.22 → rgapi-0.1.24}/DEV.md

@@ -9,7 +9,7 @@ src/walk.rs       ignore/globset/grep-regex-backed path walking and filtering
 src/search.rs     grep-regex/grep-searcher-backed searching
 src/block.rs      blank-line-delimited block grouping, matching, and block context
 src/python.rs     PyO3 classes and private core functions
-python/rgapi/     public Python wrappers over `rgapi._core`
+python/rgapi/     public Python wrappers over `rgapi._core`, plus the `rgapi-nbrg` CLI
 tests/            pytest coverage for the Python API
 ```
 
@@ -34,14 +34,13 @@ Release flow is: release first, then bump - `ship-release` does both.
 2. Confirm the release version in `Cargo.toml` (`[package].version`).
 3. Run `ship-release`. It tags `v<version>`, pushes branch and tag (CI builds and publishes), then bumps `Cargo.toml`, refreshes the editable install, and pushes the bump without a tag.
 
-The GitHub workflow builds wheels for Python 3.10-3.13 on Linux and macOS and publishes artifacts to GitHub Releases and PyPI when a `v*` tag is pushed.
+The GitHub workflow builds wheels for Python 3.10-3.13 on Linux and macOS and publishes the Rust crate, GitHub release artifacts, and PyPI package when a `v*` tag is pushed.
 
 ## Design notes
 
 Paths in `fd`, `walk`, `rg`, and `rg_iter` results are relative to the requested root and use `/` 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 16 bits of CRC-32 over the line's UTF-8 bytes); `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, symlink, filesystem, hidden, and ignore options are direct `ignore::WalkBuilder` settings. `rg_iter` exposes the same parallel search stream that `rg` collects by default; `paths=True` and `count=True` consume that stream with different reducers. Binary files and invalid UTF-8 are skipped for now.
 
-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 = String`, 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.
+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 = String`, 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.
 
 Async API: `fda`, `fda_iter`, `rga`, `rga_iter`, `nbrga`, and `nbrga_iter` wrap the corresponding private core operations. `rga(summary=True)` uses `_core.block_search_async`; ordinary `rga` uses `_core.rg_async`. Each collected core function takes a Python callback, runs on Rust threads through the generic `stream_async` helper, and delivers with one GIL attach at the end. Iterator forms use `stream_iter_async` and attach once per batch. The Python side settles an `asyncio.Future` or feeds an `asyncio.Queue` via `loop.call_soon_threadsafe`; no Python thread blocks and `asyncio.to_thread` is not involved. `AsyncHandle.cancel()` sets the same atomic flag used by the Rust iterators.
 

{rgapi-0.1.22 → rgapi-0.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.22
+Version: 0.1.24
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore>=1.14.6
@@ -77,8 +77,7 @@ pip install rgapi
 
 ## Semantics
 
-`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore`, `.ignore`, and the usual ripgrep filters apply by default. `.rgignore` files are also honored and take precedence over `.gitignore`. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable all ignore filtering (including `.rgignore`). Symlinks are not followed unless `follow_links=True`; `same_file_system=True` avoids crossing filesystem boundaries. Traversal is parallel, and result order is not guaranteed; use `sorted(...)` if order matters.
-`root` arguments accept `str` or `pathlib.Path` and expand `~`; `.`, `./`, and paths containing `..` work across the sync and async APIs.
+`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore`, `.ignore`, and the usual ripgrep filters apply by default. `.rgignore` files are also honored and take precedence over `.gitignore`. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable all ignore filtering (including `.rgignore`). Symlinks are not followed unless `follow_links=True`; `same_file_system=True` avoids crossing filesystem boundaries. Traversal is parallel, and result order is not guaranteed; use `sorted(...)` if order matters. `root` arguments accept `str` or `pathlib.Path` and expand `~`; `.`, `./`, and paths containing `..` work across the sync and async APIs.
 
 `fd` adds fd-like filtering on top of `walk`: `pattern` is a smart-case regex matched against each basename, and `include`/`exclude` use glob syntax. Lowercase patterns match case-insensitively; a pattern containing uppercase letters is case-sensitive. Use `path_re` when matching the slash-separated relative path instead. `glob=` is accepted as an alias for `include=`. A basename glob such as `*.py` also matches recursively, so it finds `src/app.py`. Use `ext="py"` or `ext=["py", "rs"]` for extension filters, which compose as AND with `include`/`glob` (so `include="src/*", ext="py"` means `src/*` *and* `*.py`, like combining `rg -g` with `-t`); use `min_depth=`/`max_depth=` to bound recursion, and `max_filesize=` to skip files above a byte limit.
 
@@ -154,6 +153,16 @@ matches      list of SearchLine rows for the matched lines within the cell
 
 Notebook walking, parsing, and matching all happen in parallel in Rust, in the same pass as the file walk. Parsing uses a lean model that reads only each cell's `id`, `cell_type`, and `source` and skips outputs and metadata, so large embedded outputs (images, plots) are never materialized. `search_nb(pattern, path, ...)` searches a single notebook file the same way.
 
+`rgapi-nbrg` exposes notebook search without requiring a Python kernel:
+
+```bash
+rgapi-nbrg 'read_csv' .
+rgapi-nbrg 'read_csv' . --cell-context 1
+rgapi-nbrg 'read_csv' nbs --glob '*.ipynb' --max-results 20
+```
+
+Run `rgapi-nbrg --help` for its discovery, matching, and output options.
+
 ## Async
 
 `fda`, `rga`, and `nbrga` are awaitable twins of `fd`, `rg`, and `nbrg`, and `fda_iter`, `rga_iter` and `nbrga_iter` are async generators that yield rows as the search finds them. All take the same arguments and return the same types as their sync counterparts.

{rgapi-0.1.22 → rgapi-0.1.24}/README.md

@@ -56,8 +56,7 @@ pip install rgapi
 
 ## Semantics
 
-`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore`, `.ignore`, and the usual ripgrep filters apply by default. `.rgignore` files are also honored and take precedence over `.gitignore`. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable all ignore filtering (including `.rgignore`). Symlinks are not followed unless `follow_links=True`; `same_file_system=True` avoids crossing filesystem boundaries. Traversal is parallel, and result order is not guaranteed; use `sorted(...)` if order matters.
-`root` arguments accept `str` or `pathlib.Path` and expand `~`; `.`, `./`, and paths containing `..` work across the sync and async APIs.
+`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore`, `.ignore`, and the usual ripgrep filters apply by default. `.rgignore` files are also honored and take precedence over `.gitignore`. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable all ignore filtering (including `.rgignore`). Symlinks are not followed unless `follow_links=True`; `same_file_system=True` avoids crossing filesystem boundaries. Traversal is parallel, and result order is not guaranteed; use `sorted(...)` if order matters. `root` arguments accept `str` or `pathlib.Path` and expand `~`; `.`, `./`, and paths containing `..` work across the sync and async APIs.
 
 `fd` adds fd-like filtering on top of `walk`: `pattern` is a smart-case regex matched against each basename, and `include`/`exclude` use glob syntax. Lowercase patterns match case-insensitively; a pattern containing uppercase letters is case-sensitive. Use `path_re` when matching the slash-separated relative path instead. `glob=` is accepted as an alias for `include=`. A basename glob such as `*.py` also matches recursively, so it finds `src/app.py`. Use `ext="py"` or `ext=["py", "rs"]` for extension filters, which compose as AND with `include`/`glob` (so `include="src/*", ext="py"` means `src/*` *and* `*.py`, like combining `rg -g` with `-t`); use `min_depth=`/`max_depth=` to bound recursion, and `max_filesize=` to skip files above a byte limit.
 
@@ -133,6 +132,16 @@ matches      list of SearchLine rows for the matched lines within the cell
 
 Notebook walking, parsing, and matching all happen in parallel in Rust, in the same pass as the file walk. Parsing uses a lean model that reads only each cell's `id`, `cell_type`, and `source` and skips outputs and metadata, so large embedded outputs (images, plots) are never materialized. `search_nb(pattern, path, ...)` searches a single notebook file the same way.
 
+`rgapi-nbrg` exposes notebook search without requiring a Python kernel:
+
+```bash
+rgapi-nbrg 'read_csv' .
+rgapi-nbrg 'read_csv' . --cell-context 1
+rgapi-nbrg 'read_csv' nbs --glob '*.ipynb' --max-results 20
+```
+
+Run `rgapi-nbrg --help` for its discovery, matching, and output options.
+
 ## Async
 
 `fda`, `rga`, and `nbrga` are awaitable twins of `fd`, `rg`, and `nbrg`, and `fda_iter`, `rga_iter` and `nbrga_iter` are async generators that yield rows as the search finds them. All take the same arguments and return the same types as their sync counterparts.

{rgapi-0.1.22 → rgapi-0.1.24}/pyproject.toml

@@ -30,6 +30,9 @@ rgapi = "rgapi.skill"
 [project.entry-points.fastaudit_safe_native]
 rgapi = "rgapi"
 
+[project.scripts]
+rgapi-nbrg = "rgapi._cli:nbrg_cli"
+
 [tool.maturin]
 features = ["extension-module"]
 python-source = "python"

rgapi-0.1.24/python/rgapi/_cli.py

@@ -0,0 +1,28 @@
+"Command-line access to notebook-aware search."
+
+from fastcore.script import call_parse
+from . import nbrg
+
+
+@call_parse(pos=['root'])
+def nbrg_cli(
+    pattern:str, # Regex pattern to search for
+    root:str='.', # File or directory to search
+    cell_context:int=0, # Neighbouring cells to include before and after matches
+    multiline:bool=False, # Allow matches across lines within a cell?
+    smart_case:bool=False, # Use case-sensitive matching when the pattern contains uppercase?
+    case:bool=False, # Force case-sensitive matching?
+    paths:bool=False, # Return only matching notebook paths?
+    count:bool=False, # Return the number of matching cells?
+    max_results:int=None, # Maximum matching cells to return
+    maxlen:int=180, # Maximum source characters displayed per cell
+    glob:str=None, # Glob selecting notebook paths
+    exclude:str=None, # Glob excluding notebook paths
+    hidden:bool=False, # Search hidden files and directories?
+    max_depth:int=None, # Maximum directory depth to search
+    timeout_ms:int=None, # Stop searching after this many milliseconds
+):
+    "Search notebook cell sources and report stable cell IDs."
+    print(nbrg(pattern, root, cell_context=cell_context, multiline=multiline, smart_case=smart_case,
+        case_sensitive=True if case else None, paths=paths, count=count, max_results=max_results, maxlen=maxlen,
+        glob=glob, exclude=exclude, hidden=hidden, max_depth=max_depth, timeout_ms=timeout_ms))

rgapi-0.1.24/python/rgapi/skill.py

@@ -0,0 +1,35 @@
+"""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.
+
+Uses ripgrep's `ignore`, `grep-regex`, and `grep-searcher` crates, including ignore files, hidden-file handling, globs, extensions, and regex semantics. Prefer these APIs to shell parsing or manual file scans in Python; use `rgstr` for held text instead of split-line loops, and `ls`/`fd` for kernel-side listings.
+
+For orientation, start with `rg(summary=True)`; use line-level results where needed and `lnhashs=True` when edits may follow. Summary blocks suit prose/config paragraphs as well as code. Display results bare; narrow oversized results with API parameters rather than joining, slicing, or reformatting them.
+
+## Search units
+
+- `rg`: lines, or `SearchBlock` rows with `summary=True`. Blank/whitespace-only lines separate blocks; multiple matches in one block yield one row. Context counts the selected unit. Summary mode cannot combine with `paths` or `count`, but supports hashed block boundaries.
+- `nbrg`: `NbResults` of `NbCell` rows from source only, never metadata/outputs. `multiline=True` matches across cell lines while `^`/`$` remain line anchors; ordinary line-oriented `rg` rejects newline patterns.
+- Traversal/search run in parallel in Rust; sort when stable order is required. `path_re`/`skip_path_re` filter paths without pruning; `skip_dir`/`skip_dir_re` prune subtrees.
+
+## Result fields and display
+
+`FileEntry` is a slash-separated relative-path `str` with lazy `size`/`mtime`/`is_dir`/`stat`. Path lists render as ls-style tables capped at `MAX_REPR`; `str(res)`/`list(res)` yield plain paths. Unfollowed symlinks remain, marked `l`; `link_target` is their target or `None` for non-links. `ls(hidden=True)` corresponds to `ls -a`.
+
+Search rows provide `asdict()`. All paths are relative to the search root:
+
+| Row | Location | Content/matches | `kind` |
+|---|---|---|---|
+| `SearchLine` | `path`, 1-based `line_number`, `lnhash` | `line` without trailing newline; `matches` as byte-offset `(start, end)` pairs on match rows | match/before/after/context |
+| `SearchBlock` | `path`, `block_index`, `start_line`, `end_line`, `start_lnhash`, `end_lnhash` | full `source`; `matches` as matching `SearchLine`s | match/context |
+| `NbCell` | `path`, `cell_index`, `cell_id`, `cell_type` (code/markdown/raw) | full `source`; `matches` as matching `SearchLine`s | match/context |
+
+Block displays use `path:start-end:source`; notebook displays use `path:cell_id:source`. Context replaces the last separator colon with `-`. Hashed block locations are `start_lnhash,end_lnhash`, or one hash for a single line. Newline runs display as ¶, retaining indentation; `maxlen` limits displayed source, not stored `source`.
+
+Notebook match previews start at the first matched line, marking omitted earlier lines as `…[Ln]` (1-based), but retain a leading directive: `#| export…[L4]needle here`. `cell_context` counts neighbouring cells. Consult individual function docs for parameters and reduction modes.
+"""
+
+from . import RgIter, fd, ls, nbrg, rg, rg_iter, rgstr
+
+__all__ = [ "RgIter", "fd", "ls", "rg", "rg_iter", "nbrg", "rgstr" ]
+
+__pyskill_params__ = {'walk_params': ('glob', 'include', 'exclude', 'hidden', 'min_depth', 'max_filesize',
+    'follow_links', 'same_file_system', 'path_re', 'skip_path_re', 'skip_dir', 'skip_dir_re')}

{rgapi-0.1.22 → rgapi-0.1.24}/rustfmt.toml

@@ -1,3 +1,4 @@
 max_width = 160
 use_small_heuristics = "Max"
 use_field_init_shorthand = true
+disable_all_formatting = true

{rgapi-0.1.22 → rgapi-0.1.24}/src/block.rs

@@ -23,11 +23,7 @@ pub struct SearchBlock {
     pub matches: Vec<SearchLine>,
 }
 
-struct BlockInfo {
-    start_line: u64,
-    end_line: u64,
-    source: String,
-}
+struct BlockInfo { start_line: u64, end_line: u64, source: String }
 
 fn split_blocks(text: &str) -> Vec<BlockInfo> {
     let mut blocks = Vec::new();
@@ -41,31 +37,20 @@ fn split_blocks(text: &str) -> Vec<BlockInfo> {
                 lines.clear();
             }
         } else {
-            if start.is_none() {
-                start = Some(line_no);
-            }
+            if start.is_none() { start = Some(line_no); }
             lines.push(line);
         }
     }
-    if let Some(first) = start {
-        blocks.push(BlockInfo { start_line: first, end_line: text.lines().count() as u64, source: lines.join("\n") });
-    }
+    if let Some(first) = start { blocks.push(BlockInfo { start_line: first, end_line: text.lines().count() as u64, source: lines.join("\n") }); }
     blocks
 }
 
 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()),
-    };
+    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 blocks = split_blocks(text);
     let hits = search_text(disp.clone(), text, matcher.clone(), 0, 0, false)?;
-    if hits.is_empty() {
-        return Ok(Vec::new());
-    }
+    if hits.is_empty() { return Ok(Vec::new()); }
     let mut matched: HashMap<usize, Vec<SearchLine>> = HashMap::new();
     for hit in hits {
         if let Some((i, _)) = blocks.iter().enumerate().find(|(_, b)| b.start_line <= hit.line_number && hit.line_number <= b.end_line) {
@@ -77,9 +62,7 @@ fn process_file(disp: String, bytes: &[u8], matcher: &RegexMatcher, before_conte
         emit.insert(*i, true);
         let start = i.saturating_sub(before_context);
         let end = (i + after_context + 1).min(blocks.len());
-        for j in start..end {
-            emit.entry(j).or_insert(false);
-        }
+        for j in start..end { emit.entry(j).or_insert(false); }
     }
     Ok(emit
         .into_iter()
@@ -109,25 +92,13 @@ fn block_entry(
     after_context: usize,
     max_depth: Option<usize>,
 ) -> Result<Vec<SearchBlock>, RgApiError> {
-    let dent = match entry {
-        Ok(dent) => dent,
-        Err(err) => return entry_err(err, max_depth).map_or(Ok(Vec::new()), Err),
-    };
+    let dent = match entry { Ok(dent) => dent, Err(err) => return entry_err(err, max_depth).map_or(Ok(Vec::new()), Err) };
     let path = dent.path();
-    let Some(ft) = dent.file_type() else {
-        return Ok(Vec::new());
-    };
-    if !ft.is_file() {
-        return Ok(Vec::new());
-    }
+    let Some(ft) = dent.file_type() else { return Ok(Vec::new()); };
+    if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(root, path);
-    if !filters.path_allowed(&rel) {
-        return Ok(Vec::new());
-    }
-    let bytes = match std::fs::read(path) {
-        Ok(bytes) => bytes,
-        Err(_) => return Ok(Vec::new()),
-    };
+    if !filters.path_allowed(&rel) { return Ok(Vec::new()); }
+    let bytes = match std::fs::read(path) { Ok(bytes) => bytes, Err(_) => return Ok(Vec::new()) };
     process_file(rel, &bytes, matcher, before_context, after_context)
 }
 
@@ -159,11 +130,7 @@ pub fn block_iter(opts: &RgOptions) -> Result<BlockIter, RgApiError> {
         filters,
         move |dent, root, filters, tx, cancel| match block_entry(dent, root, filters, &matcher, before_context, after_context, max_depth) {
             Ok(blocks) => {
-                for block in blocks {
-                    if cancel.load(Ordering::Relaxed) || tx.send(Ok(block)).is_err() {
-                        return WalkState::Quit;
-                    }
-                }
+                for block in blocks { if cancel.load(Ordering::Relaxed) || tx.send(Ok(block)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
             }
             Err(err) => {

{rgapi-0.1.22 → rgapi-0.1.24}/src/lib.rs

@@ -14,26 +14,12 @@ pub use search::{MatchSpan, RgIter, RgOptions, SearchKind, SearchLine, compile_r
 pub use walk::{FindIter, FindOptions, StreamIter, find, find_iter};
 
 #[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)
-    }
-}
+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())
-    }
-}
+impl From<std::io::Error> for RgApiError { fn from(err: std::io::Error) -> Self { Self::new(err.to_string()) } }

{rgapi-0.1.22 → rgapi-0.1.24}/src/nb.rs

@@ -49,10 +49,7 @@ pub struct NbCell {
 // Lean notebook model: only the fields we search; outputs/metadata are skipped by serde
 // without being allocated, which is the whole memory win over materializing the JSON in Python.
 #[derive(Deserialize)]
-struct RawNb {
-    #[serde(default)]
-    cells: Vec<RawCell>,
-}
+struct RawNb { #[serde(default)] cells: Vec<RawCell> }
 
 #[derive(Deserialize)]
 struct RawCell {
@@ -66,11 +63,7 @@ struct RawCell {
 
 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(),
-        }
+        match &self.id { Some(serde_json::Value::String(s)) => s.clone(), Some(v) => v.to_string(), None => index.to_string() }
     }
 }
 
@@ -84,46 +77,25 @@ enum Source {
     Empty,
 }
 
-impl Source {
-    fn text(&self) -> String {
-        match self {
-            Source::Lines(v) => v.concat(),
-            Source::Text(s) => s.clone(),
-            Source::Empty => String::new(),
-        }
-    }
-}
+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()),
-    };
+    let nb: RawNb = match serde_json::from_slice(bytes) { Ok(nb) => nb, Err(_) => return Ok(Vec::new()) };
     let n = nb.cells.len();
     let mut info = Vec::with_capacity(n);
     let mut matched: Vec<(usize, Vec<SearchLine>)> = Vec::new();
     for (i, cell) in nb.cells.iter().enumerate() {
         let src = cell.source.text();
         let hits = search_text(disp.clone(), &src, matcher.clone(), 0, 0, multiline)?;
-        if !hits.is_empty() {
-            matched.push((i, hits));
-        }
+        if !hits.is_empty() { matched.push((i, hits)); }
         info.push((cell.id_string(i), cell.cell_type.clone().unwrap_or_default(), src));
     }
-    if matched.is_empty() {
-        return Ok(Vec::new());
-    }
+    if matched.is_empty() { return Ok(Vec::new()); }
     let mut emit: BTreeMap<usize, bool> = BTreeMap::new(); // index -> is_match
-    for (i, _) in &matched {
-        emit.insert(*i, true);
-    }
+    for (i, _) in &matched { emit.insert(*i, true); }
     if cell_context > 0 {
-        for (i, _) in &matched {
-            for j in i.saturating_sub(cell_context)..(i + cell_context + 1).min(n) {
-                emit.entry(j).or_insert(false);
-            }
-        }
+        for (i, _) in &matched { for j in i.saturating_sub(cell_context)..(i + cell_context + 1).min(n) { emit.entry(j).or_insert(false); } }
     }
     let mut matched: HashMap<usize, Vec<SearchLine>> = matched.into_iter().collect();
     let mut out = Vec::with_capacity(emit.len());
@@ -139,9 +111,7 @@ fn compile_nb_regex(pattern: &str, case_sensitive: Option<bool>, smart_case: boo
     compile_regex(pattern, case_sensitive, smart_case, multiline).map_err(|e| {
         if !multiline && e.to_string().contains("not allowed in a regex") {
             RgApiError::new(format!("{e}; pass multiline=True to let the pattern match across lines within a cell"))
-        } else {
-            e
-        }
+        } else { e }
     })
 }
 
@@ -155,10 +125,7 @@ pub fn nb_search_file(
     multiline: bool,
 ) -> Result<Vec<NbCell>, RgApiError> {
     let matcher = compile_nb_regex(pattern, case_sensitive, smart_case, multiline)?;
-    let bytes = match std::fs::read(path) {
-        Ok(b) => b,
-        Err(_) => return Ok(Vec::new()),
-    };
+    let bytes = match std::fs::read(path) { Ok(b) => b, Err(_) => return Ok(Vec::new()) };
     process_file(display_path, &bytes, &matcher, cell_context, multiline)
 }
 
@@ -171,25 +138,13 @@ fn nb_entry(
     multiline: bool,
     max_depth: Option<usize>,
 ) -> Result<Vec<NbCell>, RgApiError> {
-    let dent = match entry {
-        Ok(dent) => dent,
-        Err(err) => return entry_err(err, max_depth).map_or(Ok(Vec::new()), Err),
-    };
+    let dent = match entry { Ok(dent) => dent, Err(err) => return entry_err(err, max_depth).map_or(Ok(Vec::new()), Err) };
     let path = dent.path();
-    let Some(ft) = dent.file_type() else {
-        return Ok(Vec::new());
-    };
-    if !ft.is_file() {
-        return Ok(Vec::new());
-    }
+    let Some(ft) = dent.file_type() else { return Ok(Vec::new()); };
+    if !ft.is_file() { return Ok(Vec::new()); }
     let rel = rel_path(root, path);
-    if !filters.path_allowed(&rel) {
-        return Ok(Vec::new());
-    }
-    let bytes = match std::fs::read(path) {
-        Ok(b) => b,
-        Err(_) => return Ok(Vec::new()),
-    };
+    if !filters.path_allowed(&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)
 }
 
@@ -223,11 +178,7 @@ pub fn nb_iter(opts: &NbOptions) -> Result<NbIter, RgApiError> {
         filters,
         move |dent, root, filters, tx, cancel| match nb_entry(dent, root, filters, &matcher, cell_context, multiline, max_depth) {
             Ok(cells) => {
-                for cell in cells {
-                    if cancel.load(Ordering::Relaxed) || tx.send(Ok(cell)).is_err() {
-                        return WalkState::Quit;
-                    }
-                }
+                for cell in cells { if cancel.load(Ordering::Relaxed) || tx.send(Ok(cell)).is_err() { return WalkState::Quit; } }
                 WalkState::Continue
             }
             Err(err) => {
@@ -238,6 +189,4 @@ pub fn nb_iter(opts: &NbOptions) -> Result<NbIter, RgApiError> {
     ))
 }
 
-pub fn nb_search(opts: &NbOptions) -> Result<Vec<NbCell>, RgApiError> {
-    nb_iter(opts)?.collect()
-}
+pub fn nb_search(opts: &NbOptions) -> Result<Vec<NbCell>, RgApiError> { nb_iter(opts)?.collect() }