rgapi 0.1.6__tar.gz → 0.1.9__tar.gz

{rgapi-0.1.6 → rgapi-0.1.9}/.github/workflows/ci.yml

@@ -7,7 +7,19 @@ on:
   pull_request:
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+      - run: pip install -e '.[dev]'
+      - run: pytest -q
+
   build:
+    needs: test
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]

{rgapi-0.1.6 → rgapi-0.1.9}/Cargo.lock

@@ -13,13 +13,13 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.12.1"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+checksum = "a4e308e67087593070530a666f7fe8815cbd2e61d8f5b7313b71b7d721d1dfde"
 dependencies = [
  "memchr",
  "regex-automata",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -163,9 +163,9 @@ checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "memmap2"
-version = "0.9.10"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3"
+checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0"
 dependencies = [
  "libc",
 ]
@@ -250,9 +250,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.45"
+version = "1.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
 dependencies = [
  "proc-macro2",
 ]
@@ -276,7 +276,7 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
 [[package]]
 name = "rgapi"
-version = "0.1.6"
+version = "0.1.9"
 dependencies = [
  "globset",
  "grep-matcher",
@@ -295,15 +295,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
-]
-
 [[package]]
 name = "serde_core"
 version = "1.0.228"

{rgapi-0.1.6 → rgapi-0.1.9}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rgapi"
-version = "0.1.6"
+version = "0.1.9"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Python API for ripgrep-style file walking and searching"

{rgapi-0.1.6 → rgapi-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.6
+Version: 0.1.9
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastship>=0.0.12 ; extra == 'dev'
@@ -35,6 +35,14 @@ for row in rg_iter("TODO", ".", include="*.py", context=2): print(row.asdict())
 rg("TODO", ".", ext="py", skip_dir=".venv", paths=True)
 ```
 
+For cell-aware search of Jupyter notebooks (see [Notebooks](#notebooks)):
+
+```python
+from rgapi import nbrg
+
+nbrg("read_csv", ".", cell_context=1)
+```
+
 For direct access to the regex, search, and walk pieces:
 
 ```python
@@ -57,7 +65,7 @@ pip install rgapi
 
 ## Semantics
 
-`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore` and the usual ripgrep filters apply by default. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable ignore filtering. 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.
+`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 `~`; `search_path` also accepts path-like file paths. Display labels such as `display_path` are stringified without expansion.
 
 `fd` adds fd-like filtering on top of `walk`: `pattern` is a substring match on the relative path, and `include`/`exclude` use glob syntax. `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, `min_depth=`/`max_depth=` to bound recursion, and `max_filesize=` to skip files above a byte limit.
@@ -82,6 +90,35 @@ matches      list of (start, end) byte offsets for match rows
 
 Search is case-sensitive by default, matching `rg`. Use `smart_case=True` for `rg --smart-case` behavior, or `case_sensitive=False` to force case-insensitive matching.
 
+## Notebooks
+
+`nbrg` searches Jupyter `.ipynb` files cell-by-cell, so results are *cells* rather than raw JSON lines. Searching a notebook with plain `rg` matches the escaped JSON text (including outputs and metadata) and reports JSON line numbers; `nbrg` instead searches each cell's reconstructed **source** and returns the cells that matched.
+
+```python
+from rgapi import nbrg
+
+nbrg("read_csv", ".")                  # cells whose source matches, across all notebooks under "."
+nbrg("read_csv", ".", cell_context=1)  # also include neighbouring cells as context
+```
+
+It finds notebooks with the fast parallel Rust walker (`fd`), then matches each cell's source through the same Rust engine as `rg` (via `search_text`), so regex behaviour and the `case_sensitive`/`smart_case` flags match `rg`. Only cell `source` is searched, not outputs or metadata. `nbrg` accepts the same discovery filters as `fd`/`rg` (`include`, `exclude`, `glob`, `hidden`, `max_depth`, `skip_dir`, …).
+
+`nbrg` returns `NbResults`, a list of `NbCell`. Each `NbCell` has:
+
+```text
+path         notebook path relative to root
+cell_index   0-based position of the cell in the notebook
+cell_id      nbformat cell id (falls back to the cell index for notebooks without ids)
+cell_type    'code', 'markdown', or 'raw'
+kind         'match' or 'context'
+source       full cell source
+matches      list of SearchLine rows for the matched lines within the cell
+```
+
+`NbCell.asdict()` returns those fields as a plain dict (with `matches` as `SearchLine` dicts). `str()`/pretty display is one truncated, newline-escaped line per cell: `path:cell_id:source` for matches and `path:cell_id-source` for context cells. A cell with several matches appears once, with every hit collected in `matches`.
+
+`cell_context=N` includes the `N` cells before and after each matching cell as `kind="context"` rows (deduplicated per notebook). `prefilter=True` first narrows candidate notebooks with `rg` before the per-cell search; it is faster on notebook-heavy trees but can miss matches whose pattern is affected by JSON escaping (quotes, backslashes, regex metacharacters straddling escapes), so it is off by default.
+
 ## Benchmarks
 
 `tools/bench.py` compares the `rg` CLI with in-process `rgapi`. Run it against a release build. One run on this machine, using best time from seven repeats:

{rgapi-0.1.6 → rgapi-0.1.9}/README.md

@@ -16,6 +16,14 @@ for row in rg_iter("TODO", ".", include="*.py", context=2): print(row.asdict())
 rg("TODO", ".", ext="py", skip_dir=".venv", paths=True)
 ```
 
+For cell-aware search of Jupyter notebooks (see [Notebooks](#notebooks)):
+
+```python
+from rgapi import nbrg
+
+nbrg("read_csv", ".", cell_context=1)
+```
+
 For direct access to the regex, search, and walk pieces:
 
 ```python
@@ -38,7 +46,7 @@ pip install rgapi
 
 ## Semantics
 
-`fd` and `walk` return slash-separated paths relative to `root`. They use the `ignore` crate, so `.gitignore` and the usual ripgrep filters apply by default. Hidden files are skipped unless `hidden=True`. Pass `ignore=False` to disable ignore filtering. 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.
+`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 `~`; `search_path` also accepts path-like file paths. Display labels such as `display_path` are stringified without expansion.
 
 `fd` adds fd-like filtering on top of `walk`: `pattern` is a substring match on the relative path, and `include`/`exclude` use glob syntax. `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, `min_depth=`/`max_depth=` to bound recursion, and `max_filesize=` to skip files above a byte limit.
@@ -63,6 +71,35 @@ matches      list of (start, end) byte offsets for match rows
 
 Search is case-sensitive by default, matching `rg`. Use `smart_case=True` for `rg --smart-case` behavior, or `case_sensitive=False` to force case-insensitive matching.
 
+## Notebooks
+
+`nbrg` searches Jupyter `.ipynb` files cell-by-cell, so results are *cells* rather than raw JSON lines. Searching a notebook with plain `rg` matches the escaped JSON text (including outputs and metadata) and reports JSON line numbers; `nbrg` instead searches each cell's reconstructed **source** and returns the cells that matched.
+
+```python
+from rgapi import nbrg
+
+nbrg("read_csv", ".")                  # cells whose source matches, across all notebooks under "."
+nbrg("read_csv", ".", cell_context=1)  # also include neighbouring cells as context
+```
+
+It finds notebooks with the fast parallel Rust walker (`fd`), then matches each cell's source through the same Rust engine as `rg` (via `search_text`), so regex behaviour and the `case_sensitive`/`smart_case` flags match `rg`. Only cell `source` is searched, not outputs or metadata. `nbrg` accepts the same discovery filters as `fd`/`rg` (`include`, `exclude`, `glob`, `hidden`, `max_depth`, `skip_dir`, …).
+
+`nbrg` returns `NbResults`, a list of `NbCell`. Each `NbCell` has:
+
+```text
+path         notebook path relative to root
+cell_index   0-based position of the cell in the notebook
+cell_id      nbformat cell id (falls back to the cell index for notebooks without ids)
+cell_type    'code', 'markdown', or 'raw'
+kind         'match' or 'context'
+source       full cell source
+matches      list of SearchLine rows for the matched lines within the cell
+```
+
+`NbCell.asdict()` returns those fields as a plain dict (with `matches` as `SearchLine` dicts). `str()`/pretty display is one truncated, newline-escaped line per cell: `path:cell_id:source` for matches and `path:cell_id-source` for context cells. A cell with several matches appears once, with every hit collected in `matches`.
+
+`cell_context=N` includes the `N` cells before and after each matching cell as `kind="context"` rows (deduplicated per notebook). `prefilter=True` first narrows candidate notebooks with `rg` before the per-cell search; it is faster on notebook-heavy trees but can miss matches whose pattern is affected by JSON escaping (quotes, backslashes, regex metacharacters straddling escapes), so it is off by default.
+
 ## Benchmarks
 
 `tools/bench.py` compares the `rg` CLI with in-process `rgapi`. Run it against a release build. One run on this machine, using best time from seven repeats:

{rgapi-0.1.6 → rgapi-0.1.9}/pyproject.toml

@@ -23,6 +23,9 @@ Homepage = "https://github.com/AnswerDotAI/rgapi"
 Repository = "https://github.com/AnswerDotAI/rgapi"
 Issues = "https://github.com/AnswerDotAI/rgapi/issues"
 
+[project.entry-points.pyskills]
+rgapi = "rgapi.skill"
+
 [project.entry-points.fastaudit_safe_native]
 rgapi = "rgapi"
 

{rgapi-0.1.6 → rgapi-0.1.9}/python/rgapi/__init__.py

@@ -196,16 +196,6 @@ def search_path(
     return SearchResults(_core.search_path(matcher, _fs_path(path), _display_path(display_path), before_context, after_context))
 
 
-__all__ = [
-    "Regex",
-    "RgIter",
-    "SearchLine",
-    "SearchResults",
-    "compile",
-    "fd",
-    "rg",
-    "rg_iter",
-    "search_path",
-    "search_text",
-    "walk",
-]
+from .nb import NbCell, NbResults, nbrg, search_nb
+
+__all__ = [ "RgIter", "fd", "rg", "rg_iter", "nbrg" ]

rgapi-0.1.9/python/rgapi/nb.py

@@ -0,0 +1,96 @@
+"Notebook-aware search: run `rg`-style search over `.ipynb` files, returning matched cells instead of raw JSON lines."
+
+import json
+from pathlib import Path
+from fastcore.meta import delegates
+
+from . import compile, fd, rg, search_text
+
+
+def _cell_source(cell):
+    src = cell.get("source", "")
+    return "".join(src) if isinstance(src, list) else src
+
+def _preview(text, width=120):
+    text = text.rstrip("\n").replace("\n", "\\n")
+    return text if len(text) <= width else text[:width] + "…"
+
+
+class NbCell:
+    "A notebook cell that matched (or provides context for) a search."
+    def __init__(self, path, cell_index, cell_id, cell_type, kind, source, matches):
+        self.path,self.cell_index,self.cell_id = path,cell_index,cell_id
+        self.cell_type,self.kind,self.source,self.matches = cell_type,kind,source,matches
+
+    def asdict(self):
+        return dict(path=self.path, cell_index=self.cell_index, cell_id=self.cell_id,
+            cell_type=self.cell_type, kind=self.kind, source=self.source,
+            matches=[m.asdict() for m in self.matches])
+
+    def __repr__(self):
+        return (f"NbCell(path={self.path!r}, cell_id={self.cell_id!r}, cell_type={self.cell_type!r}, "
+                f"kind={self.kind!r}, matches={len(self.matches)})")
+
+    def __str__(self):
+        sep = ":" if self.kind == "match" else "-"
+        return f"{self.path}:{self.cell_id}{sep}{_preview(self.source)}"
+
+    def _repr_pretty_(self, p, cycle): p.text("..." if cycle else str(self))
+
+
+class NbResults(list):
+    "List of `NbCell` rows with rg-style text display."
+    def __str__(self): return "\n".join(map(str, self))
+    def _repr_pretty_(self, p, cycle): p.text("..." if cycle else str(self))
+
+
+def search_nb(
+    matcher,                 # Compiled `Regex` from `compile()`
+    path,                    # Notebook file to search (expands `~`)
+    cell_context:int=0,      # Cells of context to include before/after each matching cell
+    display_path:str=None    # Path stored in results; defaults to `path`
+) -> NbResults:
+    "Search one `.ipynb` file's cell sources with a compiled matcher."
+    disp = display_path if display_path is not None else str(path)
+    try: nb = json.loads(Path(path).expanduser().read_text())
+    except (ValueError, OSError, UnicodeDecodeError): return NbResults()
+    cells = nb.get("cells")
+    if not isinstance(cells, list): return NbResults()
+    info,matched = {},{}
+    for i,cell in enumerate(cells):
+        if not isinstance(cell, dict): continue
+        src = _cell_source(cell)
+        info[i] = (str(cell.get("id", i)), cell.get("cell_type", ""), src)
+        hits = [m for m in search_text(matcher, src, path=disp) if m.kind == "match"]
+        if hits: matched[i] = hits
+    if not matched: return NbResults()
+    emit = {i:"match" for i in matched}
+    if cell_context:
+        for i in matched:
+            for j in range(max(0, i-cell_context), min(len(cells), i+cell_context+1)): emit.setdefault(j, "context")
+    res = NbResults()
+    for i in sorted(emit):
+        if i not in info: continue
+        cid,ctype,src = info[i]
+        res.append(NbCell(disp, i, cid, ctype, emit[i], src, matched.get(i, [])))
+    return res
+
+
+@delegates(fd, but=["ext", "files", "dirs"])
+def nbrg(
+    pattern:str,                  # Regex pattern to search for
+    root:str=".",                 # Directory to search (expands `~`)
+    prefilter:bool=False,         # Pre-narrow notebooks with `rg` before per-cell search (may miss escape-affected patterns)
+    cell_context:int=0,           # Cells of context to include before/after each matching cell
+    case_sensitive:bool|None=None,# True/False forces case; None allows `smart_case`
+    smart_case:bool=False,        # Match `rg --smart-case` behavior
+    **kwargs
+) -> NbResults:
+    "Search `.ipynb` cell sources under `root`, returning matched cells."
+    matcher = compile(pattern, case_sensitive=case_sensitive, smart_case=smart_case)
+    if prefilter: paths = rg(pattern, root, ext="ipynb", case_sensitive=case_sensitive, smart_case=smart_case, paths=True, **kwargs)
+    else: paths = fd(root, ext="ipynb", **kwargs)
+    base = Path(root).expanduser()
+    res = NbResults()
+    for rel in sorted(paths): res += search_nb(matcher, base/rel, cell_context=cell_context, display_path=rel)
+    return res

rgapi-0.1.9/python/rgapi/skill.py

@@ -0,0 +1,34 @@
+"""Fast and flexible file discovery and search for Python. Use this when code needs `fd`-style file finding or `rg`-style searching.
+
+rgapi wraps the same `ignore`, `grep-regex`, and `grep-searcher` crates ripgrep uses, so `.gitignore`/`.ignore`/`.rgignore`, hidden-file handling, glob/ext filters, and regex matching all behave like `rg`. Walking and searching run in parallel and most work stays in Rust, so results come back as structured Python objects instead of CLI text to parse. Prefer rgapi over shelling out to `rg`/`fd` or scanning files by hand: you get typed rows, byte-offset match spans, and lazy iteration.
+
+Core APIs:
+- `fd(root=".", ...)` finds paths with fd-style filters (`pattern` substring, `include`/`exclude`/`glob`, `ext`); returns slash-separated relative paths.
+- `rg(pattern, root=".", ...)` searches and returns `SearchResults` (or `paths=True` for unique matched paths, `count=True` for a match-span total). NB: The `SearchResults` repr shows an rg-style multiline string, which is usually the most ergonomic approach.
+- `nbrg(pattern, root=".", cell_context=0, ...)` searches Jupyter `.ipynb` files (cell source only) and returns matched cells as `NbResults`/`NbCell`, which have a nice repr like rg(). Use this for notebooks rather than `rg`, to avoid escaping problems, and to get back message IDs.
+
+SearchLine rows:
+  kind         'match', 'before', 'after', or 'context'
+  path         path relative to root
+  line_number  1-based line number
+  line         line text without the trailing newline
+  matches      list of (start, end) byte offsets, for 'match' rows
+  asdict()     returns the row fields as a plain dict
+
+NbCell rows (from `nbrg`):
+  path/cell_index/cell_id/cell_type    locate the cell ('code'/'markdown'/'raw')
+  kind         'match' or 'context'
+  source       full cell source
+  matches      list of SearchLine rows for the matched lines within the cell
+  asdict()     returns the cell fields as a plain dict
+`cell_context=N` adds N neighbour cells as 'context'. `prefilter=True` narrows notebooks with `rg` first (faster, but can miss patterns affected by JSON escaping; off by default).
+
+Important:
+Traversal is parallel and result order is NOT guaranteed; wrap in `sorted(...)` if you need stable order. `path_re`/`skip_path_re` filter the returned/searched paths but do not prune traversal; use `skip_dir`/`skip_dir_re` to prune whole subtrees for speed. Run `doc(func)` for full parameter docments.
+"""
+
+from . import Regex, RgIter, SearchLine, SearchResults, compile, fd, rg, rg_iter, search_path, search_text, walk
+from . import NbCell, NbResults, nbrg, search_nb
+
+__all__ = [ "RgIter", "fd", "rg", "rg_iter", "nbrg" ]
+

{rgapi-0.1.6 → rgapi-0.1.9}/src/python.rs

@@ -234,6 +234,7 @@ fn walk_py(
         same_file_system,
         files,
         dirs,
+        panic_probe: false,
     };
     find(&opts).map_err(|e| PyValueError::new_err(e.to_string()))
 }
@@ -277,6 +278,7 @@ fn find_py(
         same_file_system,
         files,
         dirs,
+        panic_probe: false,
     };
     find(&opts).map_err(|e| PyValueError::new_err(e.to_string()))
 }
@@ -365,6 +367,7 @@ fn rg_py(
         smart_case,
         before_context,
         after_context,
+        panic_probe: false,
     };
     let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
     collect_rg_py(py, iter)
@@ -412,12 +415,37 @@ fn rg_iter_py(
         smart_case,
         before_context,
         after_context,
+        panic_probe: false,
     };
     rg_iter_core(&opts)
         .map(|inner| RgIterPy { inner })
         .map_err(|e| PyValueError::new_err(e.to_string()))
 }
 
+#[pyfunction(name = "panic_probe")]
+#[pyo3(signature = (root=".", walk=false))]
+fn panic_probe_py(py: Python<'_>, root: &str, walk: bool) -> PyResult<()> {
+    let root = PathBuf::from(root);
+    if walk {
+        let opts = FindOptions {
+            root,
+            panic_probe: true,
+            ..FindOptions::default()
+        };
+        find(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
+    } else {
+        let opts = RgOptions {
+            root,
+            pattern: "panic_probe".to_string(),
+            panic_probe: true,
+            ..RgOptions::default()
+        };
+        let iter = rg_iter_core(&opts).map_err(|e| PyValueError::new_err(e.to_string()))?;
+        collect_rg_py(py, iter)?;
+    }
+    Ok(())
+}
+
 impl From<SearchLine> for SearchLinePy {
     fn from(line: SearchLine) -> Self {
         Self {
@@ -442,5 +470,6 @@ fn _core(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(rg_iter_py, m)?)?;
     m.add_function(wrap_pyfunction!(search_text_py, m)?)?;
     m.add_function(wrap_pyfunction!(search_path_py, m)?)?;
+    m.add_function(wrap_pyfunction!(panic_probe_py, m)?)?;
     Ok(())
 }

{rgapi-0.1.6 → rgapi-0.1.9}/src/search.rs

@@ -1,3 +1,4 @@
+use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::{Path, PathBuf};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
@@ -69,6 +70,7 @@ pub struct RgOptions {
     pub smart_case: bool,
     pub before_context: usize,
     pub after_context: usize,
+    pub panic_probe: bool,
 }
 
 impl Default for RgOptions {
@@ -93,6 +95,7 @@ impl Default for RgOptions {
             smart_case: false,
             before_context: 0,
             after_context: 0,
+            panic_probe: false,
         }
     }
 }
@@ -179,6 +182,7 @@ fn run_parallel_search(
     filter_dirs(&mut walker, &root, filters.clone());
     let before_context = opts.before_context;
     let after_context = opts.after_context;
+    let panic_probe = opts.panic_probe;
     walker.build_parallel().run(|| {
         let tx = tx.clone();
         let root = root.clone();
@@ -188,16 +192,27 @@ fn run_parallel_search(
         let after_context = after_context;
         let cancel = cancel.clone();
         Box::new(move |entry| {
-            search_entry(
-                entry,
-                &root,
-                &filters,
-                &matcher,
-                before_context,
-                after_context,
-                &tx,
-                &cancel,
-            )
+            catch_unwind(AssertUnwindSafe(|| {
+                if panic_probe {
+                    panic!("rgapi: deliberate panic for tests (panic_probe)");
+                }
+                search_entry(
+                    entry,
+                    &root,
+                    &filters,
+                    &matcher,
+                    before_context,
+                    after_context,
+                    &tx,
+                    &cancel,
+                )
+            }))
+            .unwrap_or_else(|_| {
+                let _ = tx.send(Err(RgApiError::new(
+                    "internal error during search (this is a bug, please report it)",
+                )));
+                WalkState::Quit
+            })
         })
     });
 }

{rgapi-0.1.6 → rgapi-0.1.9}/src/walk.rs

@@ -1,3 +1,4 @@
+use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::path::{Path, PathBuf};
 use std::sync::{mpsc, Arc};
 
@@ -27,6 +28,7 @@ pub struct FindOptions {
     pub same_file_system: bool,
     pub files: bool,
     pub dirs: bool,
+    pub panic_probe: bool,
 }
 
 impl Default for FindOptions {
@@ -49,6 +51,7 @@ impl Default for FindOptions {
             same_file_system: false,
             files: true,
             dirs: false,
+            panic_probe: false,
         }
     }
 }
@@ -79,13 +82,25 @@ pub fn find(opts: &FindOptions) -> Result<Vec<String>, RgApiError> {
     let pattern = opts.pattern.clone();
     let files = opts.files;
     let dirs = opts.dirs;
+    let panic_probe = opts.panic_probe;
     walker.build_parallel().run(|| {
         let tx = tx.clone();
         let root = root.clone();
         let filters = filters.clone();
         let pattern = pattern.clone();
         Box::new(move |entry| {
-            match find_entry(entry, &root, &filters, pattern.as_deref(), files, dirs) {
+            let outcome = catch_unwind(AssertUnwindSafe(|| {
+                if panic_probe {
+                    panic!("rgapi: deliberate panic for tests (panic_probe)");
+                }
+                find_entry(entry, &root, &filters, pattern.as_deref(), files, dirs)
+            }))
+            .unwrap_or_else(|_| {
+                Err(RgApiError::new(
+                    "internal error during walk (this is a bug, please report it)",
+                ))
+            });
+            match outcome {
                 Ok(Some(path)) => {
                     if tx.send(Ok(path)).is_err() {
                         return WalkState::Quit;
@@ -170,6 +185,9 @@ pub(crate) fn configure_walker(
     same_file_system: bool,
 ) {
     walker.standard_filters(ignore);
+    if ignore {
+        walker.add_custom_ignore_filename(".rgignore");
+    }
     walker.hidden(!hidden);
     walker.require_git(false);
     walker.max_depth(max_depth);

{rgapi-0.1.6 → rgapi-0.1.9}/tests/test_rgapi.py

@@ -1,7 +1,8 @@
-import _thread, threading
+import _thread, json, threading
 
 import pytest
 
+from rgapi import _core
 from rgapi import Regex, SearchResults, compile, fd, rg, rg_iter, search_path, search_text, walk
 
 
@@ -72,6 +73,20 @@ def test_path_filters_prune_dirs_and_follow_links(tmp_path):
     assert fd(str(tmp_path), path_re=r"linked/.*\.py$", follow_links=False) == []
     assert fd(str(tmp_path), path_re=r"linked/.*\.py$", follow_links=True) == ["linked/app.py"]
 
+def test_rgignore_is_honored(tmp_path):
+    (tmp_path / ".rgignore").write_text("only_rg.txt\n")
+    (tmp_path / "only_rg.txt").write_text("hi\n")
+    (tmp_path / "keep.txt").write_text("hi\n")
+    assert set(fd(str(tmp_path))) == {"keep.txt"}
+    assert set(fd(str(tmp_path), ignore=False)) == {"keep.txt", "only_rg.txt"}
+
+def test_rgignore_can_override_gitignore(tmp_path):
+    (tmp_path / ".gitignore").write_text("*/\n")
+    (tmp_path / ".rgignore").write_text("!*/\n")
+    (tmp_path / "sub").mkdir()
+    (tmp_path / "sub" / "app.py").write_text("hi\n")
+    assert "sub/app.py" in set(fd(str(tmp_path)))
+
 def test_depth_size_and_filesystem_options(tmp_path):
     (tmp_path / "top.txt").write_text("TODO\n")
     sub = tmp_path / "sub"
@@ -121,6 +136,15 @@ def test_rg_returns_structured_matches_context_and_relative_paths(tmp_path):
     assert str(stream) == repr(stream)
 
 
+def test_worker_panic_surfaces_as_error_not_truncation(tmp_path):
+    # A panic inside a parallel search/walk worker must raise, not silently end the
+    # result stream (which would look like "no matches"). `_core.panic_probe` arms the
+    # panic flag and runs the real search/walk machinery so the catch_unwind path is exercised.
+    (tmp_path / "a.py").write_text("TODO here\n")
+    with pytest.raises(Exception): _core.panic_probe(str(tmp_path))             # search workers
+    with pytest.raises(Exception): _core.panic_probe(str(tmp_path), walk=True)  # walk workers
+
+
 def test_search_path_skips_binary_and_invalid_utf8(tmp_path):
     (tmp_path / "bin.dat").write_bytes(b"TODO before\n\0TODO after\n")
     (tmp_path / "bad.txt").write_bytes(b"TODO\xff\n")
@@ -164,3 +188,107 @@ def test_direct_regex_and_search_apis(tmp_path):
     assert [(r.kind, r.path, r.line_number, r.line, r.matches) for r in path_res] == [
         ("match", "display.py", 2, "TODO here", [(0, 4)])]
     assert path_res[0].asdict() == dict(kind="match", path="display.py", line_number=2, line="TODO here", matches=[(0, 4)])
+
+
+def write_nb(path, cells):
+    nb = {"cells": cells, "metadata": {}, "nbformat": 4, "nbformat_minor": 5}
+    path.write_text(json.dumps(nb))
+
+def _cell(cell_type, source, cid=None, outputs=None):
+    c = {"cell_type": cell_type, "metadata": {}, "source": source}
+    if cell_type == "code":
+        c["execution_count"] = None
+        c["outputs"] = outputs or []
+    if cid is not None: c["id"] = cid
+    return c
+
+
+def test_nbrg_source_only_with_cells(tmp_path):
+    from rgapi import nbrg
+    write_nb(tmp_path / "nb.ipynb", [
+        _cell("code", ["import os\n", "def foo():\n", "    return 1\n"], cid="c1",
+              outputs=[{"output_type": "stream", "name": "stdout", "text": ["foo ran\n"]}]),
+        _cell("code", ["print('hi')\n"], cid="c2",
+              outputs=[{"output_type": "stream", "name": "stdout", "text": ["foo in output\n"]}]),
+        _cell("markdown", ["# Title\n", "use foo here\n"], cid="m1"),
+    ])
+    res = nbrg("foo", str(tmp_path))
+    # c2 has 'foo' only in its output, so source-only search must skip it
+    assert {c.cell_id for c in res} == {"c1", "m1"}
+    c1 = next(c for c in res if c.cell_id == "c1")
+    assert c1.cell_type == "code" and c1.kind == "match"
+    assert [m.line_number for m in c1.matches] == [2]
+    assert c1.matches[0].line == "def foo():"
+    assert c1.matches[0].matches == [(4, 7)]
+    m1 = next(c for c in res if c.cell_id == "m1")
+    assert m1.cell_type == "markdown"
+    assert [m.line for m in m1.matches] == ["use foo here"]
+
+
+def test_nbrg_string_source_and_missing_id(tmp_path):
+    from rgapi import nbrg
+    write_nb(tmp_path / "nb.ipynb", [_cell("code", "x = 1\nfoo = 2\n")])
+    res = nbrg("foo", str(tmp_path))
+    assert len(res) == 1
+    assert res[0].cell_id == "0"
+    assert res[0].matches[0].line == "foo = 2"
+    assert res[0].matches[0].line_number == 2
+
+
+def test_nbrg_multiple_matches_single_cell_appears_once(tmp_path):
+    from rgapi import nbrg
+    write_nb(tmp_path / "nb.ipynb", [
+        _cell("code", ["foo = 1\n", "bar = 2\n", "baz = foo + foo\n"], cid="c1"),
+    ])
+    res = nbrg("foo", str(tmp_path))
+    assert len(res) == 1                                     # cell appears once, not once per match
+    assert [c.cell_id for c in res] == ["c1"]
+    cell = res[0]
+    assert [m.line_number for m in cell.matches] == [1, 3]   # both matching lines kept
+    assert cell.matches[1].matches == [(6, 9), (12, 15)]     # two spans on the same line
+
+
+def test_nbrg_cell_context(tmp_path):
+    from rgapi import nbrg
+    write_nb(tmp_path / "nb.ipynb", [
+        _cell("code", ["a = 1\n"], cid="c0"),
+        _cell("code", ["target = 2\n"], cid="c1"),
+        _cell("code", ["b = 3\n"], cid="c2"),
+        _cell("code", ["c = 4\n"], cid="c3"),
+    ])
+    res = nbrg("target", str(tmp_path), cell_context=1)
+    kinds = {c.cell_id: c.kind for c in res}
+    assert kinds == {"c0": "context", "c1": "match", "c2": "context"}
+
+
+def test_nbrg_skips_bad_json_and_prefilter_parity(tmp_path):
+    from rgapi import nbrg
+    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))
+    b = nbrg("read_csv", str(tmp_path), prefilter=True)
+    assert {c.cell_id for c in a} == {"g1"}
+    assert {c.cell_id for c in b} == {"g1"}
+
+
+def test_search_nb_single_and_asdict_str(tmp_path):
+    from rgapi import compile, search_nb
+    p = tmp_path / "nb.ipynb"
+    write_nb(p, [_cell("code", ["def foo():\n", "    return 1\n"], cid="c1")])
+    res = search_nb(compile("foo"), p, display_path="nb.ipynb")
+    assert len(res) == 1
+    cell = res[0]
+    assert str(cell) == "nb.ipynb:c1:def foo():\\n    return 1"   # cell-oriented: whole cell, newlines escaped
+    d = cell.asdict()
+    assert d["cell_id"] == "c1" and d["cell_type"] == "code" and d["kind"] == "match"
+    assert d["matches"][0]["line"] == "def foo():"
+
+
+def test_nbcell_str_truncates_and_escapes(tmp_path):
+    from rgapi import compile, search_nb
+    p = tmp_path / "nb.ipynb"
+    write_nb(p, [_cell("code", ["x = '" + "a" * 500 + "'  # foo\n"], cid="c1")])
+    s = str(search_nb(compile("foo"), p, display_path="nb.ipynb")[0])
+    assert "\n" not in s            # newlines escaped to a single display line
+    assert s.endswith("…")          # long cell is truncated
+    assert s.startswith("nb.ipynb:c1:")