use std::path::{Path, PathBuf};
use super::{
DeclaredPattern, ManifestCache, WorkspaceDiagnostic, WorkspaceDiagnosticKind, WorkspaceInfo,
collect_declared_patterns, expand_patterns_to_workspaces, missing_dir_patterns,
pnpm_workspace_packages, register_matched_workspace,
undeclared::{is_ignored_scan_dir, is_undeclared_scan_skip_dir},
};
pub(super) fn is_nested_project_dir(dir: &Path) -> bool {
dir.join("package.json").is_file() && dir.join(PNPM_WORKSPACE_FILE).is_file()
}
const PNPM_WORKSPACE_FILE: &str = "pnpm-workspace.yaml";
pub struct ManifestPatternMatcher {
positive: globset::GlobSet,
negative: globset::GlobSet,
}
impl ManifestPatternMatcher {
#[must_use]
pub fn load(root: &Path) -> Self {
let mut positive = globset::GlobSetBuilder::new();
let mut negative = globset::GlobSetBuilder::new();
for declared in collect_declared_patterns(root, &[]).unwrap_or_default() {
let (builder, pattern) = match declared.pattern.strip_prefix('!') {
Some(rest) => (&mut negative, rest),
None => (&mut positive, declared.pattern.as_str()),
};
let pattern = crate::glob_validation::normalize_path_pattern(pattern);
let pattern = if pattern.ends_with('/') {
format!("{pattern}*")
} else {
pattern.to_owned()
};
if let Ok(glob) = crate::glob_validation::compile_path_glob(&pattern) {
builder.add(glob);
}
}
Self {
positive: positive
.build()
.unwrap_or_else(|_| globset::GlobSet::empty()),
negative: negative
.build()
.unwrap_or_else(|_| globset::GlobSet::empty()),
}
}
#[must_use]
pub fn declares(&self, root: &Path, dir: &Path) -> bool {
let relative = dir.strip_prefix(root).unwrap_or(dir);
let relative = relative.to_string_lossy().replace('\\', "/");
self.positive.is_match(relative.as_str()) && !self.negative.is_match(relative.as_str())
}
}
#[must_use]
pub fn is_independent_pnpm_project(root: &Path, ws_root: &Path) -> bool {
if !ws_root.join(PNPM_WORKSPACE_FILE).is_file() || ws_root.strip_prefix(root).is_err() {
return false;
}
let canonical = |path: &Path| dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
if canonical(ws_root) == canonical(root) {
return false;
}
!ManifestPatternMatcher::load(root).declares(root, ws_root)
}
pub(super) struct NestedProjectScan<'a> {
pub(super) root: &'a Path,
pub(super) canonical_root: &'a Path,
pub(super) ignore_patterns: &'a crate::IgnorePatternSet,
}
fn nested_project_roots(scan: &NestedProjectScan<'_>) -> Vec<PathBuf> {
let matcher = ManifestPatternMatcher::load(scan.root);
let is_candidate = |dir: &Path| {
is_nested_project_dir(dir)
&& !matcher.declares(scan.root, dir)
&& !is_ignored_scan_dir(scan.root, dir, scan.ignore_patterns)
};
let mut roots = Vec::new();
for top in scan_dirs(scan.root) {
if is_nested_project_dir(&top) {
if is_candidate(&top) {
roots.push(top);
}
continue;
}
roots.extend(
scan_dirs(&top)
.into_iter()
.filter(|child| is_candidate(child)),
);
}
roots.sort();
roots
}
fn scan_dirs(parent: &Path) -> Vec<PathBuf> {
let Ok(entries) = std::fs::read_dir(parent) else {
return Vec::new();
};
entries
.filter_map(Result::ok)
.filter(|entry| !is_undeclared_scan_skip_dir(&entry.file_name().to_string_lossy()))
.map(|entry| entry.path())
.filter(|path| path.is_dir())
.collect()
}
pub(super) fn collect_nested_project_workspaces(
scan: &NestedProjectScan<'_>,
workspaces: &mut Vec<(WorkspaceInfo, Vec<String>)>,
diagnostics: &mut Vec<WorkspaceDiagnostic>,
manifest_cache: &mut ManifestCache,
) {
let canonical = |path: &Path| dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf());
let known: rustc_hash::FxHashSet<PathBuf> = workspaces
.iter()
.map(|(ws, _)| canonical(&ws.root))
.collect();
for dir in nested_project_roots(scan) {
let canonical_dir = canonical(&dir);
if !canonical_dir.starts_with(scan.canonical_root) {
continue;
}
if !known.contains(&canonical_dir) {
let registered_before = workspaces.len();
register_matched_workspace(
scan.root,
dir.clone(),
workspaces,
diagnostics,
manifest_cache,
);
if workspaces.len() > registered_before {
diagnostics.push(WorkspaceDiagnostic::new(
scan.root,
dir.clone(),
WorkspaceDiagnosticKind::NestedProjectRoot,
));
}
}
let declared = nested_declared_patterns(&dir);
diagnostics.extend(missing_dir_patterns(&dir, &declared).map(|missing| {
WorkspaceDiagnostic::new(
scan.root,
missing.source.clone(),
WorkspaceDiagnosticKind::WorkspacePatternDirMissing {
pattern: missing.pattern.clone(),
},
)
}));
let patterns = nested_member_patterns(scan.root, &dir, &declared);
workspaces.extend(expand_patterns_to_workspaces(
scan.root,
&patterns,
scan.canonical_root,
scan.ignore_patterns,
diagnostics,
manifest_cache,
));
}
}
pub(super) fn nested_declared_patterns(project_dir: &Path) -> Vec<DeclaredPattern> {
let source = project_dir.join(PNPM_WORKSPACE_FILE);
let Ok(content) = std::fs::read_to_string(&source) else {
return Vec::new();
};
pnpm_workspace_packages(&content)
.into_iter()
.map(|pattern| DeclaredPattern {
pattern,
source: source.clone(),
})
.collect()
}
fn nested_member_patterns(
root: &Path,
project_dir: &Path,
declared: &[DeclaredPattern],
) -> Vec<String> {
let relative = project_dir.strip_prefix(root).unwrap_or(project_dir);
let prefix = relative.to_string_lossy().replace('\\', "/");
declared
.iter()
.filter_map(|declared| prefix_member_pattern(&prefix, &declared.pattern))
.collect()
}
fn prefix_member_pattern(prefix: &str, pattern: &str) -> Option<String> {
let (negation, mut body) = match pattern.strip_prefix('!') {
Some(rest) => ("!", rest),
None => ("", pattern),
};
while let Some(rest) = body.strip_prefix("./") {
body = rest;
}
if body.is_empty()
|| body == "."
|| body.starts_with('/')
|| Path::new(body).is_absolute()
|| body.split('/').any(|segment| segment == "..")
{
return None;
}
Some(format!(
"{negation}{}",
crate::glob_validation::literal_dir_glob(prefix, body)
))
}