Allow splitting entity path expressions with whitespace (#7782)

### What
- Resolves: #7740

This is a little tricky since we don't want to split on whitespace that
happens to show up between a + or - and the expression.

Logic seems correct from testing.

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using examples from latest `main` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/7782?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/7782?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG
* [x] If applicable, add a new check to the [release
checklist](https://github.com/rerun-io/rerun/blob/main/tests/python/release_checklist)!
* [x] If have noted any breaking changes to the log API in
`CHANGELOG.md` and the migration guide

- [PR Build Summary](https://build.rerun.io/pr/7782)
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

To run all checks from `main`, comment on the PR with `@rerun-bot
full-check`.

---------

Co-authored-by: Emil Ernerfeldt <[email protected]>

.github/workflows/labels.yml

@@ -39,4 +39,4 @@ jobs:
         with:
           mode: minimum
           count: 1
-          labels: "📊 analytics, 🟦 blueprint, 🪳 bug, 🌊 C++ API, CLI, codegen/idl, 🧑‍💻 dev experience, dependencies, 📖 documentation, 💬 discussion, examples, exclude from changelog, 🪵 Log-API, 📉 performance, 🐍 Python API, ⛃ re_datastore, 🔍 re_query, 📺 re_viewer, 🔺 re_renderer, 🚜 refactor, ⛴ release, 🦀 Rust API, 🔨 testing, ui, 🕸️ web"
+          labels: "📊 analytics, 🟦 blueprint, 🪳 bug, 🌊 C++ API, CLI, codegen/idl, 🧑‍💻 dev experience, dependencies, 📖 documentation, 💬 discussion, examples, exclude from changelog, 🪵 Log & send APIs, 📉 performance, 🐍 Python API, ⛃ re_datastore, 🔍 re_query, 📺 re_viewer, 🔺 re_renderer, 🚜 refactor, ⛴ release, 🦀 Rust API, 🔨 testing, ui, 🕸️ web"

crates/store/re_log_types/src/path/entity_path_filter.rs

@@ -169,6 +169,75 @@ impl TryFrom<&str> for EntityPathFilter {
     }
 }
 
+/// Split a string into whitespace-separated tokens with extra logic.
+///
+/// Specifically, we allow for whitespace between `+`/`-` and the following token.
+///
+/// Additional rules:
+///  - Escaped whitespace never results in a split.
+///  - Otherwise always split on `\n` (even if it follows a `+` or `-` character).
+///  - Only consider `+` and `-` characters as special if they are the first character of a token.
+///  - Split on whitespace does not following a relevant `+` or `-` character.
+fn split_whitespace_smart(path: &'_ str) -> Vec<&'_ str> {
+    #![allow(clippy::unwrap_used)]
+
+    // We parse on bytes, and take care to only split on either side of a one-byte ASCII,
+    // making the `from_utf8(…)`s below safe to unwrap.
+    let mut bytes = path.as_bytes();
+
+    let mut tokens = vec![];
+
+    // Start by ignoring any leading whitespace
+    while !bytes.is_empty() {
+        let mut i = 0;
+        let mut is_in_escape = false;
+        let mut is_include_exclude = false;
+        let mut new_token = true;
+
+        // Find the next unescaped whitespace character not following a '+' or '-' character
+        while i < bytes.len() {
+            let is_unescaped_whitespace = !is_in_escape && bytes[i].is_ascii_whitespace();
+
+            let is_unescaped_newline = !is_in_escape && bytes[i] == b'\n';
+
+            if is_unescaped_newline || (!is_include_exclude && is_unescaped_whitespace) {
+                break;
+            }
+
+            is_in_escape = bytes[i] == b'\\';
+
+            if bytes[i] == b'+' || bytes[i] == b'-' {
+                is_include_exclude = new_token;
+            } else if !is_unescaped_whitespace {
+                is_include_exclude = false;
+                new_token = false;
+            }
+
+            i += 1;
+        }
+        if i > 0 {
+            tokens.push(&bytes[..i]);
+        }
+
+        // Continue skipping whitespace characters
+        while i < bytes.len() {
+            if is_in_escape || !bytes[i].is_ascii_whitespace() {
+                break;
+            }
+            is_in_escape = bytes[i] == b'\\';
+            i += 1;
+        }
+
+        bytes = &bytes[i..];
+    }
+
+    // Safety: we split at proper character boundaries
+    tokens
+        .iter()
+        .map(|token| std::str::from_utf8(token).unwrap())
+        .collect()
+}
+
 impl EntityPathFilter {
     /// Parse an entity path filter from a string while ignore syntax errors.
     ///
@@ -187,7 +256,8 @@ impl EntityPathFilter {
     ///
     /// Conflicting rules are resolved by the last rule.
     pub fn parse_forgiving(rules: &str, subst_env: &EntityPathSubs) -> Self {
-        Self::from_query_expressions_forgiving(rules.split('\n'), subst_env)
+        let split_rules = split_whitespace_smart(rules);
+        Self::from_query_expressions_forgiving(split_rules, subst_env)
     }
 
     /// Build a filter from a list of query expressions.
@@ -243,7 +313,8 @@ impl EntityPathFilter {
         rules: &str,
         subst_env: &EntityPathSubs,
     ) -> Result<Self, EntityPathFilterParseError> {
-        Self::from_query_expressions_strict(rules.split('\n'), subst_env)
+        let split_rules = split_whitespace_smart(rules);
+        Self::from_query_expressions_strict(split_rules, subst_env)
     }
 
     /// Build a filter from a list of query expressions.
@@ -891,3 +962,32 @@ mod tests {
         }
     }
 }
+
+#[test]
+fn test_split_whitespace_smart() {
+    assert_eq!(split_whitespace_smart("/world"), vec!["/world"]);
+    assert_eq!(split_whitespace_smart("a b c"), vec!["a", "b", "c"]);
+    assert_eq!(split_whitespace_smart("a\nb\tc  "), vec!["a", "b", "c"]);
+    assert_eq!(split_whitespace_smart(r"a\ b c"), vec![r"a\ b", "c"]);
+
+    assert_eq!(
+        split_whitespace_smart(" + a - b + c"),
+        vec!["+ a", "- b", "+ c"]
+    );
+    assert_eq!(
+        split_whitespace_smart("+ a -\n b + c"),
+        vec!["+ a", "-", "b", "+ c"]
+    );
+    assert_eq!(
+        split_whitespace_smart("/weird/path- +/oth- erpath"),
+        vec!["/weird/path-", "+/oth-", "erpath"]
+    );
+    assert_eq!(
+        split_whitespace_smart(r"+world/** -/world/points"),
+        vec!["+world/**", "-/world/points"]
+    );
+    assert_eq!(
+        split_whitespace_smart(r"+ world/** - /world/points"),
+        vec!["+ world/**", "- /world/points"]
+    );
+}

rerun_py/tests/unit/test_dataframe.py

@@ -173,6 +173,25 @@ def test_full_view(self) -> None:
         assert table.num_columns == 1
         assert table.num_rows == 1
 
+    def test_content_filters(self) -> None:
+        filter_expressions = [
+            "+/** -/static_text",
+            """
+            +/**
+            -/static_text
+            """,
+            {"/** -/static_text": ["Position3D", "Color"]},
+        ]
+
+        for expr in filter_expressions:
+            view = self.recording.view(index="my_index", contents=expr)
+
+            table = view.select().read_all()
+
+            # my_index, log_time, log_tick, points, colors
+            assert table.num_columns == 5
+            assert table.num_rows == 2
+
     def test_select_columns(self) -> None:
         view = self.recording.view(index="my_index", contents="points")
         index_col = rr.dataframe.IndexColumnSelector("my_index")