Revert the original "#ns" suffix hack

Now that the Cleaner is "tag namespace aware", the fs tag iterator does
not need to return tags that belong to another namespace. It does
however need to recognize and skip files that represent tags in another
namespace. But now it will once again impossible to name a tag with a
path that would put it in a different namespace.

Signed-off-by: J Robert Ray <[email protected]>

Author: jrray

crates/spfs/src/storage/fs/tag.rs

@@ -491,7 +491,7 @@ impl Stream for TagStreamIter {
         use TagStreamIterState::*;
         match self.state.take() {
             // TODO: this walkdir loop is not actually async and should be fixed
-            Some(WalkingTree) => loop {
+            Some(WalkingTree) => 'entry: loop {
                 let entry = self.inner.next();
                 match entry {
                     None => break Ready(None),
@@ -510,6 +510,28 @@ impl Stream for TagStreamIter {
                         if path.extension() != Some(OsStr::new(TAG_EXT)) {
                             continue;
                         }
+
+                        // This iterator skips over any namespaces; since the
+                        // walkdir iterator will descend into any directory,
+                        // the whole parent hierarchy needs to be checked for
+                        // the namespace marker.
+                        //
+                        // The root itself may be a namespace.
+                        let mut parent = path.parent();
+                        while let Some(p) = parent {
+                            if p == self.root {
+                                break;
+                            }
+                            if p.file_name()
+                                .and_then(|s| s.to_str())
+                                .map(|p| p.ends_with(TAG_NAMESPACE_MARKER))
+                                .unwrap_or_default()
+                            {
+                                continue 'entry;
+                            }
+                            parent = p.parent();
+                        }
+
                         let spec = match tag_from_path(&path, &self.root) {
                             Err(err) => break Ready(Some(Err(err))),
                             Ok(spec) => spec,

crates/spfs/src/tracking/tag.rs

@@ -353,7 +353,6 @@ fn _find_org_error(org: &str) -> Option<usize> {
     for (i, ch) in org.chars().enumerate() {
         match ch {
             '-' | '_' | '.' | '/' => (),
-            '#' if &org[i..] == "#ns" => return None,
             _ => {
                 if !ch.is_ascii_alphanumeric() {
                     return Some(i);