Closes #535 --prune option

src/app.rs

@@ -127,6 +127,7 @@ pub fn build_app() -> App<'static, 'static> {
                 .short("0")
                 .overrides_with("print0"),
         )
+        .arg(arg("prune").long("prune").hidden_short_help(true))
         .arg(arg("depth").long("max-depth").short("d").takes_value(true))
         // support --maxdepth as well, for compatibility with rg
         .arg(
@@ -351,6 +352,10 @@ fn usage() -> HashMap<&'static str, Help> {
         , "Separate results by the null character"
         , "Separate search results by the null character (instead of newlines). Useful for \
            piping results to 'xargs'.");
+    doc!(h, "prune"
+        , "Do not descend into matched directories"
+        , "When a directory matches the pattern, fd does not descend into it but still shows \
+           all matches at the same level as that directory.");
     doc!(h, "depth"
         , "Set maximum search depth (default: none)"
         , "Limit the directory traversal to a given depth. By default, there is no limit \

src/internal/opts.rs

@@ -34,6 +34,9 @@ pub struct FdOptions {
     /// Whether elements of output should be separated by a null character
     pub null_separator: bool,
 
+    /// Whether to not descend into matching directories.
+    pub prune: bool,
+
     /// The maximum search depth, or `None` if no maximum search depth should be set.
     ///
     /// A depth of `1` includes all files under the current directory, a depth of `2` also includes

src/main.rs

@@ -211,6 +211,7 @@ fn main() {
         follow_links: matches.is_present("follow"),
         one_file_system: matches.is_present("one-file-system"),
         null_separator: matches.is_present("null_separator"),
+        prune: matches.is_present("prune"),
         max_depth: matches
             .value_of("depth")
             .or_else(|| matches.value_of("rg-depth"))

src/walk.rs

@@ -362,6 +362,17 @@ fn spawn_senders(
                 return ignore::WalkState::Continue;
             }
 
+            // when pruning, don't descend into matching dirs
+            // note that prune requires pattern
+            let walk_action = if config.prune
+                && pattern.as_str().len() != 0
+                && entry.file_type().map_or(false, |e| e.is_dir())
+            {
+                ignore::WalkState::Skip
+            } else {
+                ignore::WalkState::Continue
+            };
+
             // Filter out unwanted extensions.
             if let Some(ref exts_regex) = config.extensions {
                 if let Some(path_str) = entry_path.file_name() {
@@ -387,10 +398,10 @@ fn spawn_senders(
                         || (file_types.empty_only && !fshelper::is_empty(&entry))
                         || !(entry_type.is_file() || entry_type.is_dir() || entry_type.is_symlink())
                     {
-                        return ignore::WalkState::Continue;
+                        return walk_action;
                     }
                 } else {
-                    return ignore::WalkState::Continue;
+                    return walk_action;
                 }
             }
 
@@ -404,13 +415,13 @@ fn spawn_senders(
                             .iter()
                             .any(|sc| !sc.is_within(file_size))
                         {
-                            return ignore::WalkState::Continue;
+                            return walk_action;
                         }
                     } else {
-                        return ignore::WalkState::Continue;
+                        return walk_action;
                     }
                 } else {
-                    return ignore::WalkState::Continue;
+                    return walk_action;
                 }
             }
 
@@ -426,7 +437,7 @@ fn spawn_senders(
                     }
                 }
                 if !matched {
-                    return ignore::WalkState::Continue;
+                    return walk_action;
                 }
             }
 
@@ -436,7 +447,7 @@ fn spawn_senders(
                 return ignore::WalkState::Quit;
             }
 
-            ignore::WalkState::Continue
+            walk_action
         })
     });
 }

tests/tests.rs

@@ -1470,3 +1470,77 @@ fn test_base_directory() {
         ),
     );
 }
+
+/// pruning (--prune)
+#[test]
+fn test_prune() {
+    let dirs = &["foo", "bar/zap/foo"];
+    let files = &[
+        "foo/a.foo",
+        "foo/b.bar",
+        "bar/zap/c.foo",
+        "bar/zap/foo/d.foo",
+    ];
+    let te = TestEnv::new(dirs, files);
+
+    // before prune
+    te.assert_output(
+        &["foo"],
+        "bar/zap/foo/d.foo
+         bar/zap/c.foo
+         bar/zap/foo
+         foo/a.foo
+         foo",
+    );
+    // with prune
+    te.assert_output(
+        &["--prune", "foo"],
+        "bar/zap/c.foo
+         bar/zap/foo
+         foo",
+    );
+
+    // --type f
+    te.assert_output(&["--prune", "--type", "f", "foo"], "bar/zap/c.foo");
+    // --type d
+    te.assert_output(
+        &["--prune", "--type", "d", "foo"],
+        "bar/zap/foo
+        foo",
+    );
+    // --prune with other options but no pattern
+    te.assert_output(
+        &["--prune", "--type", "d"],
+        "bar/zap/foo
+         bar/zap
+         bar
+         foo",
+    );
+
+    // --max-depth
+    // before prune
+    te.assert_output(
+        &["--max-depth", "3", "foo"],
+        "bar/zap/foo
+         bar/zap/c.foo
+         foo/a.foo
+         foo",
+    );
+    // with prune
+    te.assert_output(
+        &["--prune", "--max-depth", "3", "foo"],
+        "bar/zap/foo
+         bar/zap/c.foo
+         foo",
+    );
+
+    // --exclude
+    // before prune
+    te.assert_output(
+        &["foo", "--exclude", "zap"],
+        "foo
+         foo/a.foo",
+    );
+    // with prune
+    te.assert_output(&["foo", "--prune", "--exclude", "zap"], "foo");
+}