lib/src/package.dart - pub.git - Git at Google

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 import 'dart:io';

 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';

 import 'exceptions.dart';
 import 'git.dart' as git;
 import 'ignore.dart';
 import 'io.dart';
 import 'log.dart' as log;
 import 'package_name.dart';
 import 'pubspec.dart';
 import 'utils.dart';

 /// A Package is a [Pubspec] and a directory where it belongs that can be used
 /// for version solving or as a node in a package graph.
 class Package {
   /// Compares [a] and [b] orders them by name then version number.
   ///
   /// This is normally used as a [Comparator] to pass to sort. This does not
   /// take a package's description or root directory into account, so multiple
   /// distinct packages may order the same.
   static int orderByNameAndVersion(Package a, Package b) {
     final name = a.name.compareTo(b.name);
     if (name != 0) return name;

     return a.version.compareTo(b.version);
   }

   /// The path to the directory containing the package.
   final String dir;

   /// A version of [dir] adapted for presenting in the terminal.
   ///
   /// If [dir] is just a parent directory like ../.. it gets replaced with
   /// the absolute dir.
   late final String presentationDir =
       p.isWithin(dir, '.') ? p.normalize(p.absolute(dir)) : dir;

   /// The name of the package.
   String get name => pubspec.name;

   /// The package's version.
   Version get version => pubspec.version;

   /// The parsed pubspec associated with this package.
   final Pubspec pubspec;

   /// The path to the entrypoint package's pubspec.
   String get pubspecPath => p.normalize(p.join(dir, 'pubspec.yaml'));

   /// The path to the entrypoint package's pubspec overrides file.
   String get pubspecOverridesPath =>
       p.normalize(p.join(dir, 'pubspec_overrides.yaml'));

   /// The (non-transitive) workspace packages.
   final List<Package> workspaceChildren;

   /// The transitive closure of [workspaceChildren] rooted at this package.
   ///
   /// Includes this package.
   Iterable<Package> get transitiveWorkspace sync* {
     final stack = [this];

     while (stack.isNotEmpty) {
       final current = stack.removeLast();
       yield current;
       // Because we pick from the end of the stack, elements are added in
       // reverse, such that they will be visited in the order they appear in the
       // list.
       stack.addAll(current.workspaceChildren.reversed);
     }
   }

   /// A collection of all overrides in the workspace.
   ///
   /// Should only be called on the workspace root.
   ///
   /// We only allow each package to be overridden once, so it is ok to collapse
   /// the overrides into a single map.
   late final Map<String, PackageRange> allOverridesInWorkspace = {
     for (final package in transitiveWorkspace)
       ...package.pubspec.dependencyOverrides,
   };

   /// The immediate dependencies this package specifies in its pubspec.
   Map<String, PackageRange> get dependencies => pubspec.dependencies;

   /// The immediate dev dependencies this package specifies in its pubspec.
   Map<String, PackageRange> get devDependencies => pubspec.devDependencies;

   /// All immediate dependencies this package specifies.
   ///
   /// This includes regular, dev dependencies, and overrides from this package.
   Map<String, PackageRange> get immediateDependencies {
     // Make sure to add overrides last so they replace normal dependencies.
     return {
       ...dependencies,
       ...devDependencies,
       ...pubspec.dependencyOverrides,
     };
   }

   /// Returns a list of paths to all Dart executables in
   /// this package's `bin` directory.
   List<String> get executablePaths {
     final binDir = p.join(dir, 'bin');
     if (!dirExists(binDir)) return <String>[];
     return [
       for (var executable in listDir(binDir, includeDirs: false))
         if (p.extension(executable) == '.dart')
           p.relative(executable, from: dir),
     ]..sort();
   }

   List<String> get executableNames =>
       executablePaths.map(p.basenameWithoutExtension).toList();

   /// Returns whether or not this package is in a Git repo.
   late final bool inGitRepo = computeInGitRepoCache();

   bool computeInGitRepoCache() {
     if (!git.isInstalled) {
       return false;
     } else {
       // If the entire package directory is ignored, don't consider it part of a
       // git repo. `git check-ignore` will return a status code of 0 for
       // ignored, 1 for not ignored, and 128 for not a Git repo.
       final result = runProcessSync(git.command!, [
         'check-ignore',
         '--quiet',
         '.',
       ], workingDir: dir);
       return result.exitCode == 1;
     }
   }

   /// Loads the package whose root directory is [dir].
   ///
   /// Will also load the workspace sub-packages of this package (recursively).
   ///
   /// [name] is the expected name of that package (e.g. the name given in the
   /// dependency), or `null` if the package being loaded is the entrypoint
   /// package.
   ///
   /// `pubspec_overrides.yaml` is only loaded if [withPubspecOverrides] is
   /// `true`.
   ///
   /// [loadPubspec] if given will be used to obtain a pubspec from a path. Also
   /// for the workspace children.
   ///
   /// This mechanism can be used to avoid loading pubspecs twice. It can also be
   /// used to override a pubspec in memory for trying out an alternative
   /// resolution.
   factory Package.load(
     String dir, {
     bool withPubspecOverrides = false,
     String? expectedName,
     required Pubspec Function(
       String path, {
       String? expectedName,
       required bool withPubspecOverrides,
     })
     loadPubspec,
   }) {
     final pubspec = loadPubspec(
       dir,
       withPubspecOverrides: withPubspecOverrides,
       expectedName: expectedName,
     );

     final workspacePackages =
         pubspec.workspace.map((workspacePath) {
           try {
             return Package.load(
               p.join(dir, workspacePath),
               loadPubspec: loadPubspec,
               withPubspecOverrides: withPubspecOverrides,
             );
           } on FileException catch (e) {
             final pubspecPath = p.join(dir, 'pubspec.yaml');
             throw FileException(
               '${e.message}\n'
               'That was included in the workspace of $pubspecPath.',
               e.path,
             );
           }
         }).toList();
     for (final package in workspacePackages) {
       if (package.pubspec.resolution != Resolution.workspace) {
         fail('''
 ${package.pubspecPath} is included in the workspace from ${p.join(dir, 'pubspec.yaml')}, but does not have `resolution: workspace`.

 See $workspacesDocUrl for more information.
 ''');
       }
     }
     return Package(pubspec, dir, workspacePackages);
   }

   /// Creates a package with [pubspec] associated with [dir].
   ///
   /// For temporary resolution attempts [pubspec] does not have to correspond
   /// to the one at disk.
   Package(this.pubspec, this.dir, this.workspaceChildren);

   /// Given a relative path within this package, returns its absolute path.
   ///
   /// This is similar to `p.join(dir, part1, ...)`, except that subclasses may
   /// override it to report that certain paths exist elsewhere than within
   /// [dir].
   String path(
     String? part1, [
     String? part2,
     String? part3,
     String? part4,
     String? part5,
     String? part6,
     String? part7,
   ]) {
     return p.join(dir, part1, part2, part3, part4, part5, part6, part7);
   }

   /// Given an absolute path within this package (such as that returned by
   /// [path] or [listFiles]), returns it relative to the package root.
   String relative(String path) {
     return p.relative(path, from: dir);
   }

   static final _basicIgnoreRules = [
     '.*', // Don't include dot-files.
     '!.htaccess', // Include .htaccess anyways.
     'pubspec.lock',
     '!pubspec.lock/', // We allow a directory called pubspec lock.
     '/pubspec_overrides.yaml',
   ];

   /// Returns a list of files that are considered to be part of this package.
   ///
   /// If [beneath] is passed, this will only return files beneath that path,
   /// which is expected to be relative to the package's root directory. If
   /// [recursive] is true, this will return all files beneath that path;
   /// otherwise, it will only return files one level beneath it.
   ///
   /// This will take .pubignore and .gitignore files into account.
   ///
   /// If [dir] is inside a git repository, all ignore files from the repo root
   /// are considered.
   ///
   /// For each directory a .pubignore takes precedence over a .gitignore.
   ///
   /// Note that the returned paths will be always be below [dir], and will
   /// always start with [dir] (thus always be relative to the current working
   /// directory) or absolute id [dir] is absolute.
   ///
   /// To convert them to paths relative to the package root, use [p.relative].
   List<String> listFiles({
     String? beneath,
     bool recursive = true,
     bool includeDirs = false,
   }) {
     final packageDir = dir;
     final root = git.repoRoot(packageDir) ?? packageDir;
     beneath =
         p
             .toUri(
               p.normalize(
                 p.relative(p.join(packageDir, beneath ?? '.'), from: root),
               ),
             )
             .path;
     if (beneath == './') beneath = '.';
     String resolve(String path) {
       if (Platform.isWindows) {
         return p.joinAll([root, ...p.posix.split(path)]);
       }
       return p.join(root, path);
     }

     /// Throws if [path] is a link that cannot resolve.
     ///
     /// Circular links will fail to resolve at some depth defined by the os.
     void verifyLink(String path) {
       final link = Link(path);
       if (link.existsSync()) {
         try {
           link.resolveSymbolicLinksSync();
         } on FileSystemException catch (e) {
           if (!link.existsSync()) {
             return;
           }
           throw DataException('Could not resolve symbolic link $path. $e');
         }
       }
     }

     /// We check each directory that it doesn't symlink-resolve to the
     /// symlink-resolution of any parent directory of itself. This avoids
     /// cycles.
     ///
     /// Cache the symlink resolutions here.
     final symlinkResolvedDirs = <String, String>{};
     String resolveDirSymlinks(String path) {
       return symlinkResolvedDirs[path] ??=
           Directory(path).resolveSymbolicLinksSync();
     }

     final result =
         Ignore.listFiles(
           beneath: beneath,
           listDir: (dir) {
             final resolvedDir = p.normalize(resolve(dir));
             verifyLink(resolvedDir);

             {
               final canonicalized = p.canonicalize(resolvedDir);
               final symlinkResolvedDir = resolveDirSymlinks(canonicalized);
               for (final parent in parentDirs(p.dirname(canonicalized))) {
                 final symlinkResolvedParent = resolveDirSymlinks(parent);
                 if (p.equals(symlinkResolvedDir, symlinkResolvedParent)) {
                   dataError('''
 Pub does not support symlink cycles.

 $symlinkResolvedDir => ${p.canonicalize(symlinkResolvedParent)}
 ''');
                 }
               }
             }
             var contents = Directory(resolvedDir).listSync(followLinks: false);

             if (!recursive) {
               contents =
                   contents.where((entity) => entity is! Directory).toList();
             }
             return contents.map((entity) {
               final relative = p.relative(entity.path, from: root);
               if (Platform.isWindows) {
                 return p.posix.joinAll(p.split(relative));
               }
               return relative;
             });
           },
           ignoreForDir: (dir) {
             final pubIgnore = resolve('$dir/.pubignore');
             final gitIgnore = resolve('$dir/.gitignore');
             final ignoreFile =
                 fileExists(pubIgnore)
                     ? pubIgnore
                     : (fileExists(gitIgnore) ? gitIgnore : null);

             final rules = [
               if (dir == beneath) ..._basicIgnoreRules,
               if (ignoreFile != null) readTextFile(ignoreFile),
             ];
             return rules.isEmpty
                 ? null
                 : Ignore(
                   rules,
                   onInvalidPattern: (pattern, exception) {
                     log.warning(
                       '$ignoreFile had invalid pattern $pattern. '
                       '${exception.message}',
                     );
                   },
                   // Ignore case on macOS and Windows, because `git clone` and
                   // `git init` will set `core.ignoreCase = true` in the local
                   // local `.git/config` file for the repository.
                   //
                   // So on Windows and macOS most users will have
                   // case-insensitive behavior with `.gitignore`, hence, it
                   // seems reasonable to do the same when we interpret
                   // `.gitignore` and `.pubignore`.
                   //
                   // There are cases where a user may have case-sensitive
                   // behavior with `.gitignore` on Windows and macOS:
                   //
                   //  (A) The user has manually overwritten the repository
                   //      configuration setting `core.ignoreCase = false`.
                   //
                   //  (B) The git-clone or git-init command that create the
                   //      repository did not deem `core.ignoreCase = true` to be
                   //      appropriate. Documentation for [git-config]][1]
                   //      implies this might depend on whether or not the
                   //      filesystem is case sensitive: > If true, this option
                   //      enables various workarounds to > enable Git to work
                   //      better on filesystems that are not > case sensitive,
                   //      like FAT.
                   //      > ...
                   //      > The default is false, except git-clone[1] or
                   //      > git-init[1] will probe and set core.ignoreCase true
                   //      > if appropriate when the repository is created.
                   //
                   // In either case, it seems likely that users on Windows and
                   // macOS will prefer case-insensitive matching. We
                   // specifically know that some tooling will generate `.PDB`
                   // files instead of `.pdb`, see: [#3003][2]
                   //
                   // [1]:
                   // https://git-scm.com/docs/git-config/2.14.6#Documentation/git-config.txt-coreignoreCase
                   // [2]: https://github.com/dart-lang/pub/issues/3003
                   ignoreCase: Platform.isMacOS || Platform.isWindows,
                 );
           },
           isDir: (dir) => dirExists(resolve(dir)),
           includeDirs: includeDirs,
         ).map(resolve).toList();
     for (final f in result) {
       verifyLink(f);
     }
     return result;
   }

   /// Applies [transform] to each package in the workspace and returns a derived
   /// package.
   Package transformWorkspace(Pubspec Function(Package) transform) {
     final workspace = {
       for (final package in transitiveWorkspace) package.dir: package,
     };
     return Package.load(
       dir,
       withPubspecOverrides: true,
       loadPubspec:
           (path, {expectedName, required withPubspecOverrides}) =>
               transform(workspace[path]!),
     );
   }
 }

 /// Reports an error if one or more of:
 ///
 /// * The graph of the workspace rooted at [root] is not a tree.
 /// * If a package name occurs twice.
 /// * If two packages in the workspace override the same package name.
 /// * A workspace package is overridden.
 /// * A pubspec not included in the workspace exists in a directory
 ///   between the root and a workspace package.
 void validateWorkspace(Package root) {
   if (root.workspaceChildren.isEmpty) return;

   /// Maps the `p.canonicalize`d dir of each workspace-child to its parent.
   final includedFrom = <String, String>{};
   final stack = [root];

   while (stack.isNotEmpty) {
     final current = stack.removeLast();
     for (final child in current.workspaceChildren) {
       final previous = includedFrom[p.canonicalize(child.dir)];
       if (previous != null) {
         if (previous == current.dir) {
           fail(
             '''
 Packages can only be included in the workspace once.

 `${p.join(child.dir, 'pubspec.yaml')}` is included twice into the workspace of `${p.join(current.dir, 'pubspec.yaml')}`''',
           );
         }
         fail('''
 Packages can only be included in the workspace once.

 `${p.join(child.dir, 'pubspec.yaml')}` is included in the workspace, both from:
 * `${p.join(current.dir, 'pubspec.yaml')}` and
 * `${p.join(previous, 'pubspec.yaml')}`.''');
       }
       includedFrom[p.canonicalize(child.dir)] = current.dir;
     }
     stack.addAll(current.workspaceChildren);
   }

   // Check that the workspace doesn't contain two packages with the same name!
   final namesSeen = <String, Package>{};
   for (final package in root.transitiveWorkspace) {
     final collision = namesSeen[package.name];
     if (collision != null) {
       fail('''
 Workspace members must have unique names.
 `${collision.pubspecPath}` and `${package.pubspecPath}` are both called "${package.name}".
 ''');
     }
     namesSeen[package.name] = package;
   }

   // Check that the workspace doesn't contain two overrides of the same package.
   // Also check that workspace packages are not overridden.
   final overridesSeen = <String, Package>{};
   for (final package in root.transitiveWorkspace) {
     for (final override in package.pubspec.dependencyOverrides.keys) {
       final collision = overridesSeen[override];
       if (collision != null) {
         fail('''
 The package `$override` is overridden in both:
 package `${collision.name}` at `${collision.dir}` and '${package.name}' at `${package.dir}`.

 Consider removing one of the overrides.
 ''');
       }
       overridesSeen[override] = package;

       if (namesSeen[override] case final Package overriddenWorkspacePackage) {
         fail('''
 Cannot override workspace packages.

 Package `$override` at `${overriddenWorkspacePackage.presentationDir}` is overridden in `${package.pubspecPath}`.
 ''');
       }
     }
   }

   // Check for pubspec.yaml files between the root and any workspace package.
   final visited = <String>{
     // By adding this to visited we will never go above the workspaceRoot.dir.
     p.canonicalize(root.dir),
   };
   for (final package in root.transitiveWorkspace
   // We don't want to look at the roots parents. The first package is always
   // the root, so skip that.
   .skip(1)) {
     // Run through all parent directories until we meet another workspace
     // package.
     for (final dir in parentDirs(package.dir).skip(1)) {
       // Stop if we meet another package directory.
       if (includedFrom.containsKey(p.canonicalize(dir))) {
         break;
       }
       if (!visited.add(p.canonicalize(dir))) {
         // We have been here before.
         break;
       }
       final pubspecCandidate = p.join(dir, 'pubspec.yaml');
       if (fileExists(pubspecCandidate)) {
         fail('''
 The file `$pubspecCandidate` is located in a directory between the workspace root at
 `${root.dir}` and a workspace package at `${package.dir}`. But is not a member of the
 workspace.

 This blocks the resolution of the package at `${package.dir}`.

 Consider removing it.

 See https://dart.dev/go/workspaces-stray-files for details.
 ''');
       }
     }
   }
 }
	// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	import 'dart:io';

	import 'package:path/path.dart' as p;
	import 'package:pub_semver/pub_semver.dart';

	import 'exceptions.dart';
	import 'git.dart' as git;
	import 'ignore.dart';
	import 'io.dart';
	import 'log.dart' as log;
	import 'package_name.dart';
	import 'pubspec.dart';
	import 'utils.dart';

	/// A Package is a [Pubspec] and a directory where it belongs that can be used
	/// for version solving or as a node in a package graph.
	class Package {
	/// Compares [a] and [b] orders them by name then version number.
	///
	/// This is normally used as a [Comparator] to pass to sort. This does not
	/// take a package's description or root directory into account, so multiple
	/// distinct packages may order the same.
	static int orderByNameAndVersion(Package a, Package b) {
	final name = a.name.compareTo(b.name);
	if (name != 0) return name;

	return a.version.compareTo(b.version);
	}

	/// The path to the directory containing the package.
	final String dir;

	/// A version of [dir] adapted for presenting in the terminal.
	///
	/// If [dir] is just a parent directory like ../.. it gets replaced with
	/// the absolute dir.
	late final String presentationDir =
	p.isWithin(dir, '.') ? p.normalize(p.absolute(dir)) : dir;

	/// The name of the package.
	String get name => pubspec.name;

	/// The package's version.
	Version get version => pubspec.version;

	/// The parsed pubspec associated with this package.
	final Pubspec pubspec;

	/// The path to the entrypoint package's pubspec.
	String get pubspecPath => p.normalize(p.join(dir, 'pubspec.yaml'));

	/// The path to the entrypoint package's pubspec overrides file.
	String get pubspecOverridesPath =>
	p.normalize(p.join(dir, 'pubspec_overrides.yaml'));

	/// The (non-transitive) workspace packages.
	final List<Package> workspaceChildren;

	/// The transitive closure of [workspaceChildren] rooted at this package.
	///
	/// Includes this package.
	Iterable<Package> get transitiveWorkspace sync* {
	final stack = [this];

	while (stack.isNotEmpty) {
	final current = stack.removeLast();
	yield current;
	// Because we pick from the end of the stack, elements are added in
	// reverse, such that they will be visited in the order they appear in the
	// list.
	stack.addAll(current.workspaceChildren.reversed);
	}
	}

	/// A collection of all overrides in the workspace.
	///
	/// Should only be called on the workspace root.
	///
	/// We only allow each package to be overridden once, so it is ok to collapse
	/// the overrides into a single map.
	late final Map<String, PackageRange> allOverridesInWorkspace = {
	for (final package in transitiveWorkspace)
	...package.pubspec.dependencyOverrides,
	};

	/// The immediate dependencies this package specifies in its pubspec.
	Map<String, PackageRange> get dependencies => pubspec.dependencies;

	/// The immediate dev dependencies this package specifies in its pubspec.
	Map<String, PackageRange> get devDependencies => pubspec.devDependencies;

	/// All immediate dependencies this package specifies.
	///
	/// This includes regular, dev dependencies, and overrides from this package.
	Map<String, PackageRange> get immediateDependencies {
	// Make sure to add overrides last so they replace normal dependencies.
	return {
	...dependencies,
	...devDependencies,
	...pubspec.dependencyOverrides,
	};
	}

	/// Returns a list of paths to all Dart executables in
	/// this package's `bin` directory.
	List<String> get executablePaths {
	final binDir = p.join(dir, 'bin');
	if (!dirExists(binDir)) return <String>[];
	return [
	for (var executable in listDir(binDir, includeDirs: false))
	if (p.extension(executable) == '.dart')
	p.relative(executable, from: dir),
	]..sort();
	}

	List<String> get executableNames =>
	executablePaths.map(p.basenameWithoutExtension).toList();

	/// Returns whether or not this package is in a Git repo.
	late final bool inGitRepo = computeInGitRepoCache();

	bool computeInGitRepoCache() {
	if (!git.isInstalled) {
	return false;
	} else {
	// If the entire package directory is ignored, don't consider it part of a
	// git repo. `git check-ignore` will return a status code of 0 for
	// ignored, 1 for not ignored, and 128 for not a Git repo.
	final result = runProcessSync(git.command!, [
	'check-ignore',
	'--quiet',
	'.',
	], workingDir: dir);
	return result.exitCode == 1;
	}
	}

	/// Loads the package whose root directory is [dir].
	///
	/// Will also load the workspace sub-packages of this package (recursively).
	///
	/// [name] is the expected name of that package (e.g. the name given in the
	/// dependency), or `null` if the package being loaded is the entrypoint
	/// package.
	///
	/// `pubspec_overrides.yaml` is only loaded if [withPubspecOverrides] is
	/// `true`.
	///
	/// [loadPubspec] if given will be used to obtain a pubspec from a path. Also
	/// for the workspace children.
	///
	/// This mechanism can be used to avoid loading pubspecs twice. It can also be
	/// used to override a pubspec in memory for trying out an alternative
	/// resolution.
	factory Package.load(
	String dir, {
	bool withPubspecOverrides = false,
	String? expectedName,
	required Pubspec Function(
	String path, {
	String? expectedName,
	required bool withPubspecOverrides,
	})
	loadPubspec,
	}) {
	final pubspec = loadPubspec(
	dir,
	withPubspecOverrides: withPubspecOverrides,
	expectedName: expectedName,
	);

	final workspacePackages =
	pubspec.workspace.map((workspacePath) {
	try {
	return Package.load(
	p.join(dir, workspacePath),
	loadPubspec: loadPubspec,
	withPubspecOverrides: withPubspecOverrides,
	);
	} on FileException catch (e) {
	final pubspecPath = p.join(dir, 'pubspec.yaml');
	throw FileException(
	'${e.message}\n'
	'That was included in the workspace of $pubspecPath.',
	e.path,
	);
	}
	}).toList();
	for (final package in workspacePackages) {
	if (package.pubspec.resolution != Resolution.workspace) {
	fail('''
	${package.pubspecPath} is included in the workspace from ${p.join(dir, 'pubspec.yaml')}, but does not have `resolution: workspace`.

	See $workspacesDocUrl for more information.
	''');
	}
	}
	return Package(pubspec, dir, workspacePackages);
	}

	/// Creates a package with [pubspec] associated with [dir].
	///
	/// For temporary resolution attempts [pubspec] does not have to correspond
	/// to the one at disk.
	Package(this.pubspec, this.dir, this.workspaceChildren);

	/// Given a relative path within this package, returns its absolute path.
	///
	/// This is similar to `p.join(dir, part1, ...)`, except that subclasses may
	/// override it to report that certain paths exist elsewhere than within
	/// [dir].
	String path(
	String? part1, [
	String? part2,
	String? part3,
	String? part4,
	String? part5,
	String? part6,
	String? part7,
	]) {
	return p.join(dir, part1, part2, part3, part4, part5, part6, part7);
	}

	/// Given an absolute path within this package (such as that returned by
	/// [path] or [listFiles]), returns it relative to the package root.
	String relative(String path) {
	return p.relative(path, from: dir);
	}

	static final _basicIgnoreRules = [
	'.*', // Don't include dot-files.
	'!.htaccess', // Include .htaccess anyways.
	'pubspec.lock',
	'!pubspec.lock/', // We allow a directory called pubspec lock.
	'/pubspec_overrides.yaml',
	];

	/// Returns a list of files that are considered to be part of this package.
	///
	/// If [beneath] is passed, this will only return files beneath that path,
	/// which is expected to be relative to the package's root directory. If
	/// [recursive] is true, this will return all files beneath that path;
	/// otherwise, it will only return files one level beneath it.
	///
	/// This will take .pubignore and .gitignore files into account.
	///
	/// If [dir] is inside a git repository, all ignore files from the repo root
	/// are considered.
	///
	/// For each directory a .pubignore takes precedence over a .gitignore.
	///
	/// Note that the returned paths will be always be below [dir], and will
	/// always start with [dir] (thus always be relative to the current working
	/// directory) or absolute id [dir] is absolute.
	///
	/// To convert them to paths relative to the package root, use [p.relative].
	List<String> listFiles({
	String? beneath,
	bool recursive = true,
	bool includeDirs = false,
	}) {
	final packageDir = dir;
	final root = git.repoRoot(packageDir) ?? packageDir;
	beneath =
	p
	.toUri(
	p.normalize(
	p.relative(p.join(packageDir, beneath ?? '.'), from: root),
	),
	)
	.path;
	if (beneath == './') beneath = '.';
	String resolve(String path) {
	if (Platform.isWindows) {
	return p.joinAll([root, ...p.posix.split(path)]);
	}
	return p.join(root, path);
	}

	/// Throws if [path] is a link that cannot resolve.
	///
	/// Circular links will fail to resolve at some depth defined by the os.
	void verifyLink(String path) {
	final link = Link(path);
	if (link.existsSync()) {
	try {
	link.resolveSymbolicLinksSync();
	} on FileSystemException catch (e) {
	if (!link.existsSync()) {
	return;
	}
	throw DataException('Could not resolve symbolic link $path. $e');
	}
	}
	}

	/// We check each directory that it doesn't symlink-resolve to the
	/// symlink-resolution of any parent directory of itself. This avoids
	/// cycles.
	///
	/// Cache the symlink resolutions here.
	final symlinkResolvedDirs = <String, String>{};
	String resolveDirSymlinks(String path) {
	return symlinkResolvedDirs[path] ??=
	Directory(path).resolveSymbolicLinksSync();
	}

	final result =
	Ignore.listFiles(
	beneath: beneath,
	listDir: (dir) {
	final resolvedDir = p.normalize(resolve(dir));
	verifyLink(resolvedDir);

	{
	final canonicalized = p.canonicalize(resolvedDir);
	final symlinkResolvedDir = resolveDirSymlinks(canonicalized);
	for (final parent in parentDirs(p.dirname(canonicalized))) {
	final symlinkResolvedParent = resolveDirSymlinks(parent);
	if (p.equals(symlinkResolvedDir, symlinkResolvedParent)) {
	dataError('''
	Pub does not support symlink cycles.

	$symlinkResolvedDir => ${p.canonicalize(symlinkResolvedParent)}
	''');
	}
	}
	}
	var contents = Directory(resolvedDir).listSync(followLinks: false);

	if (!recursive) {
	contents =
	contents.where((entity) => entity is! Directory).toList();
	}
	return contents.map((entity) {
	final relative = p.relative(entity.path, from: root);
	if (Platform.isWindows) {
	return p.posix.joinAll(p.split(relative));
	}
	return relative;
	});
	},
	ignoreForDir: (dir) {
	final pubIgnore = resolve('$dir/.pubignore');
	final gitIgnore = resolve('$dir/.gitignore');
	final ignoreFile =
	fileExists(pubIgnore)
	? pubIgnore
	: (fileExists(gitIgnore) ? gitIgnore : null);

	final rules = [
	if (dir == beneath) ..._basicIgnoreRules,
	if (ignoreFile != null) readTextFile(ignoreFile),
	];
	return rules.isEmpty
	? null
	: Ignore(
	rules,
	onInvalidPattern: (pattern, exception) {
	log.warning(
	'$ignoreFile had invalid pattern $pattern. '
	'${exception.message}',
	);
	},
	// Ignore case on macOS and Windows, because `git clone` and
	// `git init` will set `core.ignoreCase = true` in the local
	// local `.git/config` file for the repository.
	//
	// So on Windows and macOS most users will have
	// case-insensitive behavior with `.gitignore`, hence, it
	// seems reasonable to do the same when we interpret
	// `.gitignore` and `.pubignore`.
	//
	// There are cases where a user may have case-sensitive
	// behavior with `.gitignore` on Windows and macOS:
	//
	// (A) The user has manually overwritten the repository
	// configuration setting `core.ignoreCase = false`.
	//
	// (B) The git-clone or git-init command that create the
	// repository did not deem `core.ignoreCase = true` to be
	// appropriate. Documentation for [git-config]][1]
	// implies this might depend on whether or not the
	// filesystem is case sensitive: > If true, this option
	// enables various workarounds to > enable Git to work
	// better on filesystems that are not > case sensitive,
	// like FAT.
	// > ...
	// > The default is false, except git-clone[1] or
	// > git-init[1] will probe and set core.ignoreCase true
	// > if appropriate when the repository is created.
	//
	// In either case, it seems likely that users on Windows and
	// macOS will prefer case-insensitive matching. We
	// specifically know that some tooling will generate `.PDB`
	// files instead of `.pdb`, see: [#3003][2]
	//
	// [1]:
	// https://git-scm.com/docs/git-config/2.14.6#Documentation/git-config.txt-coreignoreCase
	// [2]: https://github.com/dart-lang/pub/issues/3003
	ignoreCase: Platform.isMacOS \|\| Platform.isWindows,
	);
	},
	isDir: (dir) => dirExists(resolve(dir)),
	includeDirs: includeDirs,
	).map(resolve).toList();
	for (final f in result) {
	verifyLink(f);
	}
	return result;
	}

	/// Applies [transform] to each package in the workspace and returns a derived
	/// package.
	Package transformWorkspace(Pubspec Function(Package) transform) {
	final workspace = {
	for (final package in transitiveWorkspace) package.dir: package,
	};
	return Package.load(
	dir,
	withPubspecOverrides: true,
	loadPubspec:
	(path, {expectedName, required withPubspecOverrides}) =>
	transform(workspace[path]!),
	);
	}
	}

	/// Reports an error if one or more of:
	///
	/// * The graph of the workspace rooted at [root] is not a tree.
	/// * If a package name occurs twice.
	/// * If two packages in the workspace override the same package name.
	/// * A workspace package is overridden.
	/// * A pubspec not included in the workspace exists in a directory
	/// between the root and a workspace package.
	void validateWorkspace(Package root) {
	if (root.workspaceChildren.isEmpty) return;

	/// Maps the `p.canonicalize`d dir of each workspace-child to its parent.
	final includedFrom = <String, String>{};
	final stack = [root];

	while (stack.isNotEmpty) {
	final current = stack.removeLast();
	for (final child in current.workspaceChildren) {
	final previous = includedFrom[p.canonicalize(child.dir)];
	if (previous != null) {
	if (previous == current.dir) {
	fail(
	'''
	Packages can only be included in the workspace once.

	`${p.join(child.dir, 'pubspec.yaml')}` is included twice into the workspace of `${p.join(current.dir, 'pubspec.yaml')}`''',
	);
	}
	fail('''
	Packages can only be included in the workspace once.

	`${p.join(child.dir, 'pubspec.yaml')}` is included in the workspace, both from:
	* `${p.join(current.dir, 'pubspec.yaml')}` and
	* `${p.join(previous, 'pubspec.yaml')}`.''');
	}
	includedFrom[p.canonicalize(child.dir)] = current.dir;
	}
	stack.addAll(current.workspaceChildren);
	}

	// Check that the workspace doesn't contain two packages with the same name!
	final namesSeen = <String, Package>{};
	for (final package in root.transitiveWorkspace) {
	final collision = namesSeen[package.name];
	if (collision != null) {
	fail('''
	Workspace members must have unique names.
	`${collision.pubspecPath}` and `${package.pubspecPath}` are both called "${package.name}".
	''');
	}
	namesSeen[package.name] = package;
	}

	// Check that the workspace doesn't contain two overrides of the same package.
	// Also check that workspace packages are not overridden.
	final overridesSeen = <String, Package>{};
	for (final package in root.transitiveWorkspace) {
	for (final override in package.pubspec.dependencyOverrides.keys) {
	final collision = overridesSeen[override];
	if (collision != null) {
	fail('''
	The package `$override` is overridden in both:
	package `${collision.name}` at `${collision.dir}` and '${package.name}' at `${package.dir}`.

	Consider removing one of the overrides.
	''');
	}
	overridesSeen[override] = package;

	if (namesSeen[override] case final Package overriddenWorkspacePackage) {
	fail('''
	Cannot override workspace packages.

	Package `$override` at `${overriddenWorkspacePackage.presentationDir}` is overridden in `${package.pubspecPath}`.
	''');
	}
	}
	}

	// Check for pubspec.yaml files between the root and any workspace package.
	final visited = <String>{
	// By adding this to visited we will never go above the workspaceRoot.dir.
	p.canonicalize(root.dir),
	};
	for (final package in root.transitiveWorkspace
	// We don't want to look at the roots parents. The first package is always
	// the root, so skip that.
	.skip(1)) {
	// Run through all parent directories until we meet another workspace
	// package.
	for (final dir in parentDirs(package.dir).skip(1)) {
	// Stop if we meet another package directory.
	if (includedFrom.containsKey(p.canonicalize(dir))) {
	break;
	}
	if (!visited.add(p.canonicalize(dir))) {
	// We have been here before.
	break;
	}
	final pubspecCandidate = p.join(dir, 'pubspec.yaml');
	if (fileExists(pubspecCandidate)) {
	fail('''
	The file `$pubspecCandidate` is located in a directory between the workspace root at
	`${root.dir}` and a workspace package at `${package.dir}`. But is not a member of the
	workspace.

	This blocks the resolution of the package at `${package.dir}`.

	Consider removing it.

	See https://dart.dev/go/workspaces-stray-files for details.
	''');
	}
	}
	}
	}