Dart笔记：glob 文件系统遍历

dependencies:
    glob: ^2.1.2

dart pub get

flutter pub add glob

import 'package:glob/glob.dart';

.\bin\glod_demo.dart
.\lib\glod_demo.dart
.\test\glod_demo_test.dart

import 'package:glob/glob.dart';
import 'package:glob/list_local_fs.dart';
final directory = Glob("**/");
// 列出当前目录中的所有子目录。
void main(List<String> arguments) {
  for (var entity in directory.listSync()) {
    print(entity.path);
  }
}

.\.dart_tool
.\.dart_tool\package_config.json
.\.gitignore
.\analysis_options.yaml
.\bin
.\bin\glod_demo.dart
.\CHANGELOG.md
.\lib
.\lib\glod_demo.dart
.\pubspec.lock
.\pubspec.yaml
.\README.md
.\test
.\test\glod_demo_test.dart

import 'package:glob/list_local_fs.dart';

/// 用于引用 globs 的正则表达式。
final _quoteRegExp = RegExp(r'[*{[?\\}\],\-()]');
/// 用于匹配和列出文件和目录的 glob。
///
/// glob 作为路径匹配整个字符串。虽然 glob 模式使用 POSIX 语法，但它可以匹配 POSIX、Windows 或 URL 路径。它期望路径使用的格式基于 [Glob.new] 的 `context` 参数；默认为当前系统的语法。
///
/// 在与 glob 匹配之前，路径会被规范化，所以例如 glob `foo/bar` 匹配路径 `foo/./bar`。相对 glob 可以匹配绝对路径，反之亦然；globs 和路径都被解释为相对于 `context.current`，默认为当前工作目录。
///
/// 当用作 [Pattern] 时，glob 将根据整个字符串是否匹配 glob 返回一个或零个匹配。这些匹配目前没有捕获组，尽管这可能在未来会改变。
class Glob implements Pattern {
  /// 用于创建此 glob 的模式。
  final String pattern;
  /// 根据此 glob 解释路径的上下文。
  final p.Context context;
  /// 如果为 true，如果路径匹配 glob 本身或递归地包含在匹配的目录中，则路径匹配。
  final bool recursive;
  /// glob 是否区分大小写匹配路径。
  bool get caseSensitive => _ast.caseSensitive;
  /// glob 的解析 AST。
  final AstNode _ast;
  /// 用于实现 [list] 和 [listSync] 的底层对象。
  ///
  /// 这不应在 [_listTreeForFileSystem] 之外直接读取。
  ListTree? _listTree;
  /// 跟踪之前使用的文件系统。如果这改变了，那么
  /// [_listTree] 必须被废弃。
  ///
  /// 这在 [_listTreeForFileSystem] 中处理。
  FileSystem? _previousFileSystem;
  /// [context] 的当前目录是否是绝对的。
  bool get _contextIsAbsolute =>
      _contextIsAbsoluteCache ??= context.isAbsolute(context.current);
  bool? _contextIsAbsoluteCache;
  /// [pattern] 是否可以匹配绝对路径。
  bool get _patternCanMatchAbsolute =>
      _patternCanMatchAbsoluteCache ??= _ast.canMatchAbsolute;
  bool? _patternCanMatchAbsoluteCache;
  /// [pattern] 是否可以匹配相对路径。
  bool get _patternCanMatchRelative =>
      _patternCanMatchRelativeCache ??= _ast.canMatchRelative;
  bool? _patternCanMatchRelativeCache;
  /// 返回 [contents]，其中包含在 globs 中有意义的字符，这些字符被反斜杠转义。
  static String quote(String contents) =>
      contents.replaceAllMapped(_quoteRegExp, (match) => '\\${match[0]}');
  /// 使用 [pattern] 创建一个新的 glob。
  ///
  /// 根据 [context] 解释与 glob 匹配的路径。默认为系统上下文。
  ///
  /// 如果 [recursive] 为 true，此 glob 不仅匹配和列出它明确匹配的文件和目录，而且还匹配那些下面的任何内容。
  ///
  /// 如果 [caseSensitive] 为 true，此 glob 只匹配和列出那些大小写与 glob 中的字符匹配的文件。否则，它无论大小写都匹配。当 [context] 为 Windows 时，默认为 `false`，否则为 `true`。
  factory Glob(String pattern,
      {p.Context? context, bool recursive = false, bool? caseSensitive}) {
    context ??= p.context;
    caseSensitive ??= context.style == p.Style.windows ? false : true;
    if (recursive) pattern += '{,/**}';
    var parser = Parser(pattern, context, caseSensitive: caseSensitive);
    return Glob._(pattern, context, parser.parse(), recursive);
  }
  Glob._(this.pattern, this.context, this._ast, this.recursive);
  /// 列出在提供的 [fileSystem] 中与 glob 匹配的 [root] 下的所有 [FileSystemEntity]。
  ///
  /// 这与 [Directory.list] 工作方式类似，但它只列出可能包含匹配 glob 的实体的目录。它不保证返回实体的顺序，尽管它确保只返回给定路径的一个实体。
  ///
  /// [root] 默认为当前工作目录。
  ///
  /// [followLinks] 与 [Directory.list] 的工作方式相同。
  Stream<FileSystemEntity> listFileSystem(FileSystem fileSystem,
      {String? root, bool followLinks = true}) {
    if (context.style != p.style) {
      throw StateError("Can't list glob \"$this\"; it matches "
          '${context.style} paths, but this platform uses ${p.style} paths.');
    }
    return _listTreeForFileSystem(fileSystem)
        .list(root: root, followLinks: followLinks);
  }
  /// 在提供的 [fileSystem] 中，同步列出在 [root] 下的所有与 glob 匹配的 [FileSystemEntity]。
  ///
  /// 这与 [Directory.listSync] 的工作方式类似，但它只列出可能包含匹配 glob 的实体的目录。它不保证返回实体的顺序，尽管它确保只返回给定路径的一个实体。
  ///
  /// [root] 默认为当前工作目录。
  ///
  /// [followLinks] 与 [Directory.list] 的工作方式相同。
  List<FileSystemEntity> listFileSystemSync(FileSystem fileSystem,
      {String? root, bool followLinks = true}) {
    if (context.style != p.style) {
      throw StateError("Can't list glob \"$this\"; it matches "
          '${context.style} paths, but this platform uses ${p.style} paths.');
    }
    return _listTreeForFileSystem(fileSystem)
        .listSync(root: root, followLinks: followLinks);
  }
  /// 返回此 glob 是否匹配 [path]。
  bool matches(String path) => matchAsPrefix(path) != null;
  @override
  Match? matchAsPrefix(String path, [int start = 0]) {
    // Globs 就像锚定的 RegExps，只匹配整个路径，所以如果匹配从第一个字符之后的任何地方开始，它就不能成功。
    if (start != 0) return null;
    if (_patternCanMatchAbsolute &&
        (_contextIsAbsolute || context.isAbsolute(path))) {
      var absolutePath = context.normalize(context.absolute(path));
      if (_ast.matches(toPosixPath(context, absolutePath))) {
        return GlobMatch(path, this);
      }
    }
    if (_patternCanMatchRelative) {
      var relativePath = context.relative(path);
      if (_ast.matches(toPosixPath(context, relativePath))) {
        return GlobMatch(path, this);
      }
    }
    return null;
  }
  @override
  Iterable<Match> allMatches(String path, [int start = 0]) {
    var match = matchAsPrefix(path, start);
    return match == null ? [] : [match];
  }
  @override
  String toString() => pattern;
  /// 处理获取可能缓存的 [ListTree] 为 [fileSystem]。
  ListTree _listTreeForFileSystem(FileSystem fileSystem) {
    // 不要为内存文件系统使用缓存的树，以避免内存泄漏。
    if (fileSystem is MemoryFileSystem) return ListTree(_ast, fileSystem);
    // 如果文件系统不同，丢弃我们缓存的 `_listTree`。
    if (fileSystem != _previousFileSystem) {
      _listTree = null;
      _previousFileSystem = fileSystem;
    }
    return _listTree ??= ListTree(_ast, fileSystem);
  }
}