Exact path matching command line option

src/cmd/cmd.rs

@@ -180,6 +180,10 @@ pub struct Query {
     /// Exclude the current directory
     #[clap(long, value_hint = ValueHint::DirPath, value_name = "path")]
     pub exclude: Option<String>,
+
+    /// Only match exact
+    #[clap(long, short)]
+    pub exact: bool,
 }
 
 /// Remove a directory from the database

src/cmd/query.rs

@@ -79,7 +79,8 @@ impl Query {
     fn get_stream<'a>(&self, db: &'a mut Database, now: Epoch) -> Result<Stream<'a>> {
         let mut options = StreamOptions::new(now)
             .with_keywords(self.keywords.iter().map(|s| s.as_str()))
-            .with_exclude(config::exclude_dirs()?);
+            .with_exclude(config::exclude_dirs()?)
+            .with_exact(self.exact);
         if !self.all {
             let resolve_symlinks = config::resolve_symlinks();
             options = options.with_exists(true).with_resolve_symlinks(resolve_symlinks);

src/db/stream.rs

@@ -1,5 +1,7 @@
+use std::ffi::OsString;
 use std::iter::Rev;
 use std::ops::Range;
+use std::path::{Component, PathBuf};
 use std::{fs, path};
 
 use glob::Pattern;
@@ -40,6 +42,10 @@ impl<'a> Stream<'a> {
                 continue;
             }
 
+            if !self.filter_by_exact(&dir.path) {
+                continue;
+            }
+
             let dir = &self.db.dirs()[idx];
             return Some(dir);
         }
@@ -91,6 +97,34 @@ impl<'a> Stream<'a> {
             if self.options.resolve_symlinks { fs::symlink_metadata } else { fs::metadata };
         resolver(path).map(|metadata| metadata.is_dir()).unwrap_or_default()
     }
+
+    fn filter_by_exact(&self, path: &str) -> bool {
+        if !self.options.exact {
+            return true;
+        }
+
+        let path = util::to_lowercase(path);
+        let path = PathBuf::from(path);
+        let mut components: Vec<Component> = path.components().collect();
+
+        for keyword in self.options.keywords.iter().rev().map(OsString::from) {
+            let idx = components.iter().rposition(|component| {
+                if let Component::Normal(sub_path) = component {
+                    sub_path == &keyword
+                } else {
+                    false
+                }
+            });
+
+            if let Some(idx) = idx {
+                components = components.drain(0..idx).collect();
+            } else {
+                return false;
+            };
+        }
+
+        true
+    }
 }
 
 pub struct StreamOptions {
@@ -109,6 +143,9 @@ pub struct StreamOptions {
     /// Whether to resolve symlinks when checking if a directory exists.
     resolve_symlinks: bool,
 
+    // Whether to only allow exact match of directory names.
+    exact: bool,
+
     /// Directories that do not exist and haven't been accessed since TTL will
     /// be lazily removed.
     ttl: Epoch,
@@ -122,6 +159,7 @@ impl StreamOptions {
             exclude: Vec::new(),
             exists: false,
             resolve_symlinks: false,
+            exact: false,
             ttl: now.saturating_sub(3 * MONTH),
         }
     }
@@ -149,6 +187,11 @@ impl StreamOptions {
         self.resolve_symlinks = resolve_symlinks;
         self
     }
+
+    pub fn with_exact(mut self, exact: bool) -> Self {
+        self.exact = exact;
+        self
+    }
 }
 
 #[cfg(test)]