feat(tests): add comprehensive tests for globSync behavior to align with Node.js fs.globSync, including directory matching and file type checks

Author: CoderSerio

__test__/glob.spec.ts

@@ -1,9 +1,23 @@
 import test from 'ava'
 import { globSync, glob } from '../index.js'
+import * as nodeFs from 'node:fs'
 import { join } from 'path'
+import { tmpdir } from 'node:os'
 
 const CWD = process.cwd()
 
+// 构造包含文件和子目录的临时目录，用于验证目录匹配行为
+function makeDirFixture(): string {
+  const base = join(tmpdir(), `hyper-glob-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
+  nodeFs.mkdirSync(join(base, 'src/sub'), { recursive: true })
+  nodeFs.writeFileSync(join(base, 'src/a.ts'), '')
+  nodeFs.writeFileSync(join(base, 'src/b.ts'), '')
+  nodeFs.writeFileSync(join(base, 'src/sub/c.ts'), '')
+  nodeFs.mkdirSync(join(base, 'dist'), { recursive: true })
+  nodeFs.writeFileSync(join(base, 'dist/out.js'), '')
+  return base
+}
+
 test('globSync: should find files in current directory', (t) => {
   const files = globSync('*.json', { cwd: CWD })
   t.true(files.length > 0)
@@ -90,3 +104,82 @@ test('async: recursive match', async (t) => {
   t.true(files.length > 0)
   t.true(files.some((f) => f.includes('src/lib.rs')))
 })
+
+// ===== 目录匹配行为（对齐 Node.js fs.globSync）=====
+
+test('globSync: "src/*" should include subdirectories matching the pattern', (t) => {
+  const base = makeDirFixture()
+  // Node.js: fs.globSync('src/*') 返回 src/ 下的文件 AND 子目录
+  const results = globSync('src/*', { cwd: base })
+  const names = results.map((r) => r.replace(/\\/g, '/'))
+  t.true(names.includes('src/a.ts'), 'should include files')
+  t.true(names.includes('src/b.ts'), 'should include files')
+  t.true(names.includes('src/sub'), 'should include directories matching the pattern')
+  // 不应包含 dist/ 下的内容（不匹配 src/*）
+  t.false(names.some((n) => n.startsWith('dist')))
+})
+
+test('globSync: "**/*.ts" should NOT include directories (dirs lack .ts extension)', (t) => {
+  const base = makeDirFixture()
+  const results = globSync('**/*.ts', { cwd: base })
+  const names = results.map((r) => r.replace(/\\/g, '/'))
+  // 所有结果应以 .ts 结尾（目录不应被包含）
+  t.true(names.length > 0)
+  t.true(
+    names.every((n) => n.endsWith('.ts')),
+    `non-.ts entry found: ${names.join(', ')}`,
+  )
+})
+
+test('globSync: "**" should include both files and directories recursively', (t) => {
+  const base = makeDirFixture()
+  const results = globSync('**', { cwd: base })
+  const names = results.map((r) => r.replace(/\\/g, '/'))
+  // 应包含目录 src、src/sub、dist
+  t.true(names.includes('src'), 'should include top-level directories')
+  t.true(names.includes('src/sub'), 'should include nested directories')
+  // 也应包含文件
+  t.true(names.some((n) => n.endsWith('.ts')))
+})
+
+test('globSync: dir-matching result should have isDirectory()=true with withFileTypes', (t) => {
+  const base = makeDirFixture()
+  const results = globSync('src/*', { cwd: base, withFileTypes: true })
+  t.true(results.length > 0)
+  const subDir = results.find((r) => typeof r === 'object' && r.name === 'sub')
+  t.truthy(subDir, 'should include sub directory as Dirent')
+  if (subDir && typeof subDir === 'object') {
+    t.true(subDir.isDirectory())
+    t.false(subDir.isFile())
+  }
+})
+
+test('dual-run: globSync "src/*" should match node:fs.globSync behavior for directories', (t) => {
+  const base = makeDirFixture()
+  // node:fs.globSync 自 v22.0.0 起稳定，对齐其目录匹配行为
+  const nodeResults: string[] = []
+  try {
+    // @ts-ignore - globSync 在旧版 Node 可能不存在
+    const nodeGlob = nodeFs.globSync as ((p: string, o: object) => string[]) | undefined
+    if (typeof nodeGlob === 'function') {
+      nodeResults.push(...nodeGlob('src/*', { cwd: base }))
+    }
+  } catch {
+    // 旧版 Node.js 不支持 fs.globSync，跳过对比
+    t.pass('node:fs.globSync not available, skipping dual-run comparison')
+    return
+  }
+  const hyperResults = globSync('src/*', { cwd: base }).map((r) => r.replace(/\\/g, '/'))
+  const nodeNorm = nodeResults.map((r) => r.replace(/\\/g, '/'))
+  // 检查 node.js 返回的目录条目我们也有
+  const nodeDirs = nodeNorm.filter((n) => {
+    try {
+      return nodeFs.statSync(join(base, n)).isDirectory()
+    } catch {
+      return false
+    }
+  })
+  for (const d of nodeDirs) {
+    t.true(hyperResults.includes(d), `should include directory '${d}' as node:fs does`)
+  }
+})

src/glob.rs

@@ -6,6 +6,13 @@ use napi_derive::napi;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 
+// ignore crate 会对文件按 override 白名单过滤，但目录无论是否匹配都会被遍历（以便
+// 递归进去找匹配的子条目）。因此目录需要单独用 dir_matcher 测试其路径是否符合模式，
+// 只有匹配的目录才加入结果——这与 Node.js fs.globSync 的行为一致：
+//   - "src/*"   → 返回 src/ 下的文件 AND 子目录
+//   - "**/*.rs" → 只返回 .rs 文件（目录不含 .rs 扩展名，不会匹配）
+//   - "**"      → 返回所有文件和目录（但不含 cwd 根节点自身）
+
 #[napi(object)]
 #[derive(Clone)]
 pub struct GlobOptions {
@@ -33,17 +40,15 @@ pub fn glob_sync(
   let with_file_types = opts.with_file_types.unwrap_or(false);
   let concurrency = opts.concurrency.unwrap_or(4) as usize;
 
-  // Build match rules (Matcher)
-  // ignore crate handles glob patterns via override
+  // 构建 override（白名单模式）：ignore crate 利用它来过滤文件；
+  // 同时保留一份 dir_matcher 副本，用于判断目录自身是否匹配模式。
   let mut override_builder = OverrideBuilder::new(&cwd);
   override_builder
     .add(&pattern)
     .map_err(|e| Error::from_reason(e.to_string()))?;
 
-  if let Some(excludes) = opts.exclude {
+  if let Some(ref excludes) = opts.exclude {
     for ex in excludes {
-      // ignore crate exclusions usually start with !, or use builder.add_ignore
-      // For simplicity here, we assume exclude is also a glob pattern, prepend !
       override_builder
         .add(&format!("!{}", ex))
         .map_err(|e| Error::from_reason(e.to_string()))?;
@@ -54,11 +59,14 @@ pub fn glob_sync(
     .build()
     .map_err(|e| Error::from_reason(e.to_string()))?;
 
+  // 复制一份给目录匹配用（walker 会消耗 overrides 所有权）
+  let dir_matcher = Arc::new(overrides.clone());
+
   let mut builder = WalkBuilder::new(&cwd);
   builder
-    .overrides(overrides) // Apply glob patterns
-    .standard_filters(opts.git_ignore.unwrap_or(true)) // Automatically handle .gitignore, .ignore etc
-    .threads(concurrency); // Core: Enable multithreading with one line!
+    .overrides(overrides)
+    .standard_filters(opts.git_ignore.unwrap_or(true))
+    .threads(concurrency);
 
   // We use two vectors to avoid enum overhead in the lock if possible, but Mutex<Vec<T>> is easier
   let result_strings = Arc::new(Mutex::new(Vec::new()));
@@ -73,68 +81,60 @@ pub fn glob_sync(
     let result_strings = result_strings_clone.clone();
     let result_dirents = result_dirents_clone.clone();
     let root = root_path.clone();
+    let dir_matcher = dir_matcher.clone();
 
     Box::new(move |entry| {
-      match entry {
-        Ok(entry) => {
-          // WalkBuilder's overrides already help us include or exclude
-          // However, ignore crate returns directories too if they match.
-          // Usually globs like "**/*.js" only match files.
-          // But "src/*" matches both.
-          // Let's keep logic: if it matches, we keep it.
-          // But typically glob returns files.
-          // If the user wants directories, pattern usually ends with /.
-          // Standard glob behavior varies.
-          // For now, let's include everything that matches the pattern overrides.
-
-          if entry.depth() == 0 {
-            return ignore::WalkState::Continue;
-          }
-
-          if entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false) {
-            return ignore::WalkState::Continue;
-          }
-
-          let path = entry.path();
-          // Make path relative to cwd if possible, similar to node-glob
-          let relative_path = path.strip_prefix(&root).unwrap_or(path);
-          let relative_path_str = relative_path.to_string_lossy().to_string();
-
-          if with_file_types {
-            let mut lock = result_dirents.lock().unwrap();
-
-            // Convert to Dirent
-            let parent_path = relative_path
-              .parent()
-              .unwrap_or(Path::new(""))
-              .to_string_lossy()
-              .to_string();
-            let name = relative_path
-              .file_name()
-              .unwrap_or_default()
-              .to_string_lossy()
-              .to_string();
-
-            let file_type = if let Some(ft) = entry.file_type() {
-              get_file_type_id(&ft)
-            } else {
-              0 // Unknown
-            };
-
-            lock.push(Dirent {
-              name,
-              parent_path,
-              file_type,
-            });
-          } else {
-            let mut lock = result_strings.lock().unwrap();
-            lock.push(relative_path_str);
-          }
-        }
-        Err(_) => {
-          // Handle errors or ignore permission errors
+      let entry = match entry {
+        Ok(e) => e,
+        Err(_) => return ignore::WalkState::Continue,
+      };
+
+      // 跳过 cwd 根节点自身（depth 0）
+      if entry.depth() == 0 {
+        return ignore::WalkState::Continue;
+      }
+
+      let path = entry.path();
+      let relative_path = path.strip_prefix(&root).unwrap_or(path);
+      let relative_path_str = relative_path.to_string_lossy().to_string();
+
+      let is_dir = entry.file_type().map(|ft| ft.is_dir()).unwrap_or(false);
+
+      if is_dir {
+        // 目录：ignore crate 只为遍历而产出，需单独测试路径是否符合模式。
+        // 与 Node.js 行为一致：模式 "src/*" 会同时返回 src/ 下的文件和子目录。
+        let matched = dir_matcher.matched(relative_path, true);
+        if !matched.is_whitelist() {
+          // 目录本身不匹配模式，但仍继续遍历以便找到匹配的子条目
+          return ignore::WalkState::Continue;
         }
+        // 目录匹配模式，加入结果后继续遍历
       }
+      // 非目录条目：ignore crate 的 override 白名单已确保它们匹配模式
+
+      if with_file_types {
+        let mut lock = result_dirents.lock().unwrap();
+        let parent_path = relative_path
+          .parent()
+          .unwrap_or(Path::new(""))
+          .to_string_lossy()
+          .to_string();
+        let name = relative_path
+          .file_name()
+          .unwrap_or_default()
+          .to_string_lossy()
+          .to_string();
+        let file_type = if let Some(ft) = entry.file_type() {
+          get_file_type_id(&ft)
+        } else {
+          0
+        };
+        lock.push(Dirent { name, parent_path, file_type });
+      } else {
+        let mut lock = result_strings.lock().unwrap();
+        lock.push(relative_path_str);
+      }
+
       ignore::WalkState::Continue
     })
   });