rgapi 0.1.6__tar.gz → 0.1.8__tar.gz

{rgapi-0.1.6 → rgapi-0.1.8}/.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.8}/Cargo.lock

@@ -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.8"
 dependencies = [
  "globset",
  "grep-matcher",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rgapi"
-version = "0.1.6"
+version = "0.1.8"
 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.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rgapi
-Version: 0.1.6
+Version: 0.1.8
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastship>=0.0.12 ; extra == 'dev'
@@ -57,7 +57,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.

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

@@ -38,7 +38,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.

{rgapi-0.1.6 → rgapi-0.1.8}/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.8}/python/rgapi/__init__.py

@@ -196,16 +196,4 @@ 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",
-]
+__all__ = [ "RgIter", "fd", "rg", "rg_iter" ]

rgapi-0.1.8/python/rgapi/skill.py

@@ -0,0 +1,24 @@
+"""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.
+
+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
+
+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
+
+__all__ = ["Regex", "RgIter", "SearchLine", "SearchResults", "compile", "fd", "rg", "rg_iter", "search_path", "search_text", "walk"]
+

{rgapi-0.1.6 → rgapi-0.1.8}/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.8}/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.8}/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.8}/tests/test_rgapi.py

@@ -2,6 +2,7 @@ import _thread, 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")