feat: configurable globstar

Author: dsherret

src/shell/commands/shopt.rs

@@ -86,6 +86,14 @@ impl ShellCommand for ShoptCommand {
                 "off"
               }
             ));
+            let _ = context.stdout.write_line(&format!(
+              "globstar\t{}",
+              if current_options.contains(ShellOptions::GLOBSTAR) {
+                "on"
+              } else {
+                "off"
+              }
+            ));
             let _ = context.stdout.write_line(&format!(
               "nullglob\t{}",
               if current_options.contains(ShellOptions::NULLGLOB) {
@@ -122,6 +130,7 @@ fn parse_option_name(name: &str) -> Option<ShellOptions> {
   match name {
     "nullglob" => Some(ShellOptions::NULLGLOB),
     "failglob" => Some(ShellOptions::FAILGLOB),
+    "globstar" => Some(ShellOptions::GLOBSTAR),
     _ => None,
   }
 }
@@ -131,6 +140,8 @@ fn option_to_name(opt: ShellOptions) -> &'static str {
     "nullglob"
   } else if opt == ShellOptions::FAILGLOB {
     "failglob"
+  } else if opt == ShellOptions::GLOBSTAR {
+    "globstar"
   } else {
     "unknown"
   }

src/shell/execute.rs

@@ -858,11 +858,25 @@ fn evaluate_word_parts(
       }
       let is_absolute = Path::new(&current_text).is_absolute();
       let cwd = state.cwd();
-      let pattern = if is_absolute {
+      let options = state.shell_options();
+
+      // when globstar is disabled, replace ** with * so it doesn't match
+      // across directory boundaries (the glob crate always treats ** as recursive)
+      let pattern_text = if !options.contains(ShellOptions::GLOBSTAR)
+        && current_text.contains("**")
+      {
+        // replace ** with * to disable recursive matching
+        current_text.replace("**", "*")
+      } else {
         current_text.clone()
+      };
+
+      let pattern = if is_absolute {
+        pattern_text.clone()
       } else {
-        format!("{}/{}", cwd.display(), current_text)
+        format!("{}/{}", cwd.display(), pattern_text)
       };
+
       let result = glob::glob_with(
         &pattern,
         glob::MatchOptions {
@@ -879,7 +893,6 @@ fn evaluate_word_parts(
           let paths =
             paths.into_iter().filter_map(|p| p.ok()).collect::<Vec<_>>();
           if paths.is_empty() {
-            let options = state.shell_options();
             // failglob - error when set
             if options.contains(ShellOptions::FAILGLOB) {
               Err(EvaluateWordTextError::NoFilesMatched { pattern })

src/shell/types.rs

@@ -38,6 +38,9 @@ bitflags! {
     /// When set, pipeline exit code is the rightmost non-zero exit code.
     /// Set via `set -o pipefail`.
     const PIPEFAIL = 1 << 2;
+    /// When set, the pattern `**` used in a pathname expansion context will
+    /// match all files and zero or more directories and subdirectories.
+    const GLOBSTAR = 1 << 3;
   }
 }
 

tests/integration_test.rs

@@ -1372,13 +1372,14 @@ async fn glob_basic() {
     .run()
     .await;
 
+  // ** only matches recursively when globstar is enabled
   TestBuilder::new()
     .directory("sub_dir/sub")
     .file("sub_dir/sub/1.txt", "1\n")
     .file("sub_dir/2.txt", "2\n")
     .file("sub_dir/other.ts", "other\n")
     .file("3.txt", "3\n")
-    .command("cat **/*.txt")
+    .command("shopt -s globstar && cat **/*.txt")
     .assert_stdout("3\n2\n1\n")
     .run()
     .await;
@@ -1389,7 +1390,7 @@ async fn glob_basic() {
     .file("sub_dir/2.txt", "2\n")
     .file("sub_dir/other.ts", "other\n")
     .file("3.txt", "3\n")
-    .command("cat $PWD/**/*.txt")
+    .command("shopt -s globstar && cat $PWD/**/*.txt")
     .assert_stdout("3\n2\n1\n")
     .run()
     .await;
@@ -1702,10 +1703,10 @@ async fn sigpipe_from_pipeline() {
 
 #[tokio::test]
 async fn shopt() {
-  // query all options (default: failglob on, nullglob off)
+  // query all options (default: failglob on, globstar off, nullglob off)
   TestBuilder::new()
     .command("shopt")
-    .assert_stdout("failglob\ton\nnullglob\toff\n")
+    .assert_stdout("failglob\ton\nglobstar\toff\nnullglob\toff\n")
     .run()
     .await;
 
@@ -1767,7 +1768,23 @@ async fn shopt() {
   // multiple options
   TestBuilder::new()
     .command("shopt -s nullglob && shopt -u failglob && shopt")
-    .assert_stdout("failglob\toff\nnullglob\ton\n")
+    .assert_stdout("failglob\toff\nglobstar\toff\nnullglob\ton\n")
+    .run()
+    .await;
+
+  // query globstar option
+  TestBuilder::new()
+    .command("shopt globstar")
+    .assert_stdout("globstar\toff\n")
+    .assert_exit_code(1) // returns 1 when option is off
+    .run()
+    .await;
+
+  // enable globstar
+  TestBuilder::new()
+    .command("shopt -s globstar && shopt globstar")
+    .assert_stdout("globstar\ton\n")
+    .assert_exit_code(0)
     .run()
     .await;
 }
@@ -1850,6 +1867,73 @@ async fn shopt_failglob() {
     .await;
 }
 
+#[tokio::test]
+async fn shopt_globstar() {
+  // without globstar: ** behaves like * (single-segment match, doesn't recurse)
+  // **/*.txt without globstar is like */*.txt - matches one level deep only
+  TestBuilder::new()
+    .directory("sub/deep")
+    .file("a.txt", "a\n")
+    .file("sub/b.txt", "b\n")
+    .file("sub/deep/c.txt", "c\n")
+    .command("echo **/*.txt")
+    .assert_stdout(&format!("sub{FOLDER_SEPERATOR}b.txt\n")) // only matches one level deep
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // with globstar: ** matches zero or more directories
+  TestBuilder::new()
+    .directory("sub/deep")
+    .file("a.txt", "a\n")
+    .file("sub/b.txt", "b\n")
+    .file("sub/deep/c.txt", "c\n")
+    .command("shopt -s globstar && echo **/*.txt | tr ' ' '\\n' | sort")
+    .assert_stdout(&format!(
+      "a.txt\nsub{FOLDER_SEPERATOR}b.txt\nsub{FOLDER_SEPERATOR}deep{FOLDER_SEPERATOR}c.txt\n"
+    ))
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // globstar with **/ prefix matches recursively in subdirectories
+  TestBuilder::new()
+    .directory("sub/deep")
+    .file("root.txt", "r\n")
+    .file("sub/nested.txt", "n\n")
+    .file("sub/deep/deeper.txt", "d\n")
+    .command("shopt -s globstar && echo **/*.txt | tr ' ' '\\n' | sort")
+    .assert_stdout(&format!(
+      "root.txt\nsub{FOLDER_SEPERATOR}deep{FOLDER_SEPERATOR}deeper.txt\nsub{FOLDER_SEPERATOR}nested.txt\n"
+    ))
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // single * still behaves normally even with globstar enabled
+  TestBuilder::new()
+    .directory("sub")
+    .file("a.txt", "a\n")
+    .file("sub/b.txt", "b\n")
+    .command("shopt -s globstar && echo *.txt")
+    .assert_stdout("a.txt\n")
+    .assert_exit_code(0)
+    .run()
+    .await;
+
+  // disabling globstar goes back to single-segment behavior
+  TestBuilder::new()
+    .directory("sub/deep")
+    .file("a.txt", "a\n")
+    .file("sub/b.txt", "b\n")
+    .file("sub/deep/c.txt", "c\n")
+    .command("shopt -s globstar && shopt -u globstar && echo **/*.txt")
+    .assert_stdout(&format!("sub{FOLDER_SEPERATOR}b.txt\n")) // back to single-level match
+    .assert_exit_code(0)
+    .run()
+    .await;
+}
+
 #[tokio::test]
 async fn pipefail_option() {
   // Without pipefail: exit code is from last command (0)