vivacity_core/

layout.rs

//! Where each package of the lock gets installed: `vendor/<name>[/<target-dir>]`
//! by LibraryInstaller, or the path composer/installers gives it when that
//! plugin is locked, allowed (`config.allow-plugins`) and ported
//! (`installers::table_for`). A single pass, before touching the disk;
//! anything not reproducible byte for byte becomes an `issue` (falls back to
//! Composer).
//!
//! The path is relative to the project root and normalised (`normalizePath`,
//! no trailing slash); that is the form Composer normalises before computing
//! `install-path` (FilesystemRepository::write).

use crate::dirs::Dirs;
use crate::installers::{self, Placement};
use crate::lock::{Lock, LockPackage};
use crate::pathutil::{find_shortest_path, normalize_path};
use serde_json::Value;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};

#[derive(Debug, Clone)]
pub struct Layout {
    /// Project root, absolute (as given, not canonicalised: the relative paths
    /// derived from it do not depend on symlinks).
    root: PathBuf,
    /// `config.vendor-dir` / `bin-dir`, project-relative.
    dirs: Dirs,
    /// name -> project-relative path (absent for a metapackage).
    paths: BTreeMap<String, String>,
    /// Emulated composer/installers tag, if the plugin is active.
    pub installers_tag: Option<String>,
    /// Installed packages (installed.json) to remove: name -> relative
    /// directory to delete (`vendor/<name>` or the plugin's target), after
    /// checking that Composer would recompute the same path today.
    removals: BTreeMap<String, String>,
}

/// `allow-plugins` verdict for a package, like PluginManager in
/// non-interactive mode.
#[derive(Debug, PartialEq, Eq)]
pub enum PluginVerdict {
    Allowed,
    /// Explicitly refused: Composer skips the plugin with a warning.
    Blocked,
    /// No rule covers it: Composer stops with an error.
    Unlisted,
}

fn absolutize(dir: &Path) -> PathBuf {
    if dir.is_absolute() {
        dir.to_path_buf()
    } else {
        std::env::current_dir()
            .map(|c| c.join(dir))
            .unwrap_or_else(|_| dir.to_path_buf())
    }
}

/// `BasePackage::packageNameToRegexp`: `{^<quote(pattern) with * -> .*>$}i`.
fn pattern_matches(pattern: &str, name: &str) -> bool {
    let p = pattern.to_ascii_lowercase();
    let n = name.to_ascii_lowercase();
    let parts: Vec<&str> = p.split('*').collect();
    if parts.len() == 1 {
        return p == n;
    }
    let mut rest = n.as_str();
    for (i, part) in parts.iter().enumerate() {
        if i == 0 {
            let Some(r) = rest.strip_prefix(part) else {
                return false;
            };
            rest = r;
        } else if i == parts.len() - 1 {
            return rest.ends_with(part);
        } else {
            let Some(pos) = rest.find(part) else {
                return false;
            };
            rest = &rest[pos + part.len()..];
        }
    }
    true
}

/// `Config::merge` for `allow-plugins`: the project value replaces the global
/// one unless both are objects, in which case
/// `array_merge($project, $global, $project)`: the project keys first, in
/// their order, then those only the global config brings. Order matters: the
/// first matching rule decides.
pub fn merged_allow_plugins(project: Option<&Value>, global: Option<&Value>) -> Option<Value> {
    match (project, global) {
        (Some(Value::Object(p)), Some(Value::Object(g))) => {
            let mut m = p.clone();
            for (k, v) in g {
                if !m.contains_key(k) {
                    m.insert(k.clone(), v.clone());
                }
            }
            Some(Value::Object(m))
        }
        (Some(p), _) => Some(p.clone()),
        (None, Some(g)) => Some(g.clone()),
        (None, None) => None,
    }
}

/// `PluginManager::parseAllowedPlugins` + `isPluginAllowed` (non-interactive).
fn plugin_verdict(allow: Option<&Value>, package: &str) -> PluginVerdict {
    match allow {
        Some(Value::Bool(true)) => PluginVerdict::Allowed,
        Some(Value::Bool(false)) => PluginVerdict::Blocked,
        Some(Value::Object(rules)) => {
            for (pattern, v) in rules {
                if pattern_matches(pattern, package) {
                    return if v == &Value::Bool(true) {
                        PluginVerdict::Allowed
                    } else {
                        PluginVerdict::Blocked
                    };
                }
            }
            PluginVerdict::Unlisted
        }
        _ => PluginVerdict::Unlisted,
    }
}

/// Verdict for `package` under the project config merged with the global one.
pub fn plugin_allowed(manifest: &Value, package: &str) -> PluginVerdict {
    let allow = merged_allow_plugins(
        manifest.get("config").and_then(|c| c.get("allow-plugins")),
        global_allow_plugins().as_ref(),
    );
    plugin_verdict(allow.as_ref(), package)
}

/// `config.allow-plugins` from COMPOSER_HOME/config.json.
pub fn global_allow_plugins() -> Option<Value> {
    global_config_value("allow-plugins")
}

/// One `config.<key>` value of COMPOSER_HOME/config.json — the global
/// layer of `Config::merge`, below the root composer.json.
pub fn global_config_value(key: &str) -> Option<Value> {
    let path = crate::fetch::composer_home()?.join("config.json");
    let v = crate::jsonfile::read(&path)?;
    v.get("config")?.get(key).cloned()
}

/// Project-relative path of a package handled by LibraryInstaller:
/// `<vendor-dir>/<name>[/<target-dir>]`.
fn vendor_rel(vendor: &str, name: &str, target_dir: Option<&str>) -> String {
    match target_dir {
        Some(t) => format!("{vendor}/{name}/{t}"),
        None => format!("{vendor}/{name}"),
    }
}

/// The active installers of a run: composer/installers' table, and
/// whether roots/wordpress-core-installer places `wordpress-core`.
#[derive(Clone, Copy, Default)]
struct Placers<'a> {
    table: Option<&'a installers::Table>,
    wp_core: bool,
    /// mnsami/composer-custom-directory-installer places `library` and
    /// `composer-plugin` packages named in `extra.installer-paths`.
    custom_dirs: bool,
}

/// Decision for a package (name, type, extra) under the current configuration.
fn place(
    vendor: &str,
    placers: Placers<'_>,
    root_extra: Option<&Value>,
    name: &str,
    package_type: &str,
    package_extra: Option<&Value>,
    target_dir: Option<&str>,
) -> Result<String, String> {
    if placers.custom_dirs && matches!(package_type, "library" | "composer-plugin") {
        if let Some(p) = custom_dir(root_extra, name, package_extra) {
            return custom_target(vendor, name, &p, "custom-directory-installer");
        }
    }
    // roots/wordpress-core-installer's `getInstallPath` for its type.
    if placers.wp_core && package_type == WP_CORE_TYPE {
        return match wp_core_dir(root_extra, name, package_extra, vendor) {
            Ok(p) => custom_target(vendor, name, &p, "wordpress-core-installer"),
            Err(e) => Err(format!("wordpress-core-installer: {e}")),
        };
    }
    let Some(table) = placers.table else {
        return Ok(vendor_rel(vendor, name, target_dir));
    };
    match installers::placement(table, root_extra, name, package_type, package_extra) {
        Ok(Placement::Vendor) => Ok(vendor_rel(vendor, name, target_dir)),
        Ok(Placement::Custom(p)) => custom_target(vendor, name, &p, "installers"),
        Err(e) => Err(format!("installers: {name} ({package_type}): {e}")),
    }
}

/// A custom install path's checks: relative, not the project root, not
/// outside it, not inside vendor/.
fn custom_target(vendor: &str, name: &str, p: &str, who: &str) -> Result<String, String> {
    {
        {
            if crate::pathutil::is_absolute_path(p) {
                return Err(format!(
                    "{who}: {name} would install at an absolute path `{p}`"
                ));
            }
            let rel = normalize_path(p);
            if rel.is_empty() || rel == "." {
                return Err(format!("{who}: {name} would install at the project root"));
            }
            if rel.starts_with("../") || rel == ".." {
                return Err(format!(
                    "{who}: {name} would install outside the project (`{p}`)"
                ));
            }
            if rel == vendor || rel.starts_with(&format!("{vendor}/")) {
                return Err(format!(
                    "{who}: {name} targets `{p}` inside {vendor}/ (not emulated: use the default vendor layout)"
                ));
            }
            Ok(rel)
        }
    }
}

/// roots/wordpress-core-installer (docs/reference/plugins/
/// wordpress-core-installer/, read at v4.0.0 — 85d3589): the package type it
/// installs, and `getInstallPath` — the root's `extra.wordpress-install-dir`
/// (a string, or a map by pretty name; PHP `empty()` rules), else the
/// package's own, else `wordpress`; `.` and the vendor directory refused
/// with the plugin's exception.
pub const CUSTOM_DIRS_PLUGIN: &str = "mnsami/composer-custom-directory-installer";

/// mnsami/composer-custom-directory-installer (docs/reference/plugins/
/// composer-custom-directory-installer/, read at 2.0.0):
/// `PackageUtils::getPackageInstallPath` — the first `extra.installer-paths`
/// entry of the root whose list names the package (exact pretty name),
/// with `{$name}` / `{$vendor}` filled in (`extra.installer-name` of the
/// package overrides the name); `None` (the default path) otherwise.
fn custom_dir(
    root_extra: Option<&Value>,
    pretty_name: &str,
    package_extra: Option<&Value>,
) -> Option<String> {
    let paths = root_extra
        .and_then(|e| e.get("installer-paths"))
        .and_then(Value::as_object)
        .filter(|m| !m.is_empty())?;
    let path = paths.iter().find_map(|(path, names)| {
        names
            .as_array()
            .is_some_and(|l| l.iter().any(|n| n.as_str() == Some(pretty_name)))
            .then(|| path.clone())
    })?;
    let (vendor, mut name) = match pretty_name.split_once('/') {
        Some((v, n)) => (v.to_owned(), n.to_owned()),
        None => (String::new(), pretty_name.to_owned()),
    };
    if let Some(n) = package_extra
        .and_then(|e| e.get("installer-name"))
        .and_then(Value::as_str)
        .filter(|n| !n.is_empty() && *n != "0")
    {
        name = n.to_owned();
    }
    Some(path.replace("{$name}", &name).replace("{$vendor}", &vendor))
}

pub const WP_CORE_PLUGIN: &str = "roots/wordpress-core-installer";
pub const WP_CORE_TYPE: &str = "wordpress-core";

fn wp_core_dir(
    root_extra: Option<&Value>,
    pretty_name: &str,
    package_extra: Option<&Value>,
    vendor: &str,
) -> Result<String, String> {
    let php_empty = |v: Option<&Value>| match v {
        None | Some(Value::Null) => true,
        Some(Value::Bool(b)) => !*b,
        Some(Value::String(s)) => s.is_empty() || s == "0",
        Some(Value::Number(n)) => n.as_f64() == Some(0.0),
        Some(Value::Array(a)) => a.is_empty(),
        Some(Value::Object(o)) => o.is_empty(),
    };
    let as_dir = |v: &Value| -> Option<String> {
        match v {
            Value::String(s) => Some(s.clone()),
            Value::Number(n) => Some(n.to_string()),
            Value::Bool(true) => Some("1".to_owned()),
            _ => None,
        }
    };
    let mut dir: Option<String> = None;
    let top = root_extra.and_then(|e| e.get("wordpress-install-dir"));
    if !php_empty(top) {
        match top {
            Some(Value::Object(map)) => {
                let entry = map.get(pretty_name);
                if !php_empty(entry) {
                    dir = entry.and_then(as_dir);
                }
            }
            Some(v) => dir = as_dir(v),
            None => {}
        }
    }
    if dir.is_none() {
        let own = package_extra.and_then(|e| e.get("wordpress-install-dir"));
        if !php_empty(own) {
            dir = own.and_then(as_dir);
        }
    }
    let dir = dir.unwrap_or_else(|| "wordpress".to_owned());
    if dir == "." || dir == vendor {
        return Err(format!(
            "Warning! {dir} is an invalid WordPress install directory (from {pretty_name})!"
        ));
    }
    Ok(dir)
}

impl Layout {
    /// Everything in vendor/ (no layout plugin), for tests and code paths
    /// that have no plugin-aware lock.
    pub fn vendor_only(project_dir: &Path, lock: &Lock, with_dev: bool) -> Layout {
        Self::vendor_only_with(project_dir, lock, with_dev, Dirs::default())
    }

    /// `vendor_only` under the given `config.vendor-dir` / `bin-dir`.
    pub fn vendor_only_with(project_dir: &Path, lock: &Lock, with_dev: bool, dirs: Dirs) -> Layout {
        let mut paths = BTreeMap::new();
        for p in lock.wanted_packages(with_dev) {
            if !p.is_virtual(false) {
                paths.insert(
                    p.name().to_owned(),
                    vendor_rel(dirs.vendor_rel(), p.name(), p.target_dir()),
                );
            }
        }
        Layout {
            root: absolutize(project_dir),
            dirs,
            paths,
            installers_tag: None,
            removals: BTreeMap::new(),
        }
    }

    /// The full pass: plugin, allow-plugins, paths, refused targets, and the
    /// removal plan for installed.json packages that went away.
    pub fn resolve(
        project_dir: &Path,
        lock: &Lock,
        manifest: &Value,
        with_dev: bool,
        plugins_enabled: bool,
    ) -> Result<Layout, Vec<String>> {
        let root = absolutize(project_dir);
        let dirs = Dirs::resolve(manifest).map_err(|e| vec![e])?;
        let vendor = dirs.vendor_rel().to_owned();
        let vendor_prefix = format!("{vendor}/");
        let mut issues: Vec<String> = Vec::new();
        let wanted: Vec<&LockPackage> = lock.wanted_packages(with_dev).collect();
        let previous = installed_packages(&root, &dirs);
        let has_state = dirs.composer_dir(&root).join("installed.json").is_file();

        // Is the plugin active? Composer loads it from installed.json
        // (PluginManager::loadInstalledPlugins) and installs it first in the
        // transaction; vivacity only emulates the states where both views
        // agree. A plugin present on one side only (added, removed, or in
        // require-dev with --no-dev) is a transition left to Composer.
        let lock_plugin = wanted.iter().find(|p| p.name() == "composer/installers");
        let prev_plugin = previous
            .iter()
            .find(|p| p["name"].as_str() == Some("composer/installers"));
        let mut table: Option<&installers::Table> = None;
        let mut installers_tag = None;
        if plugins_enabled && (lock_plugin.is_some() || prev_plugin.is_some()) {
            let allow = merged_allow_plugins(
                manifest.get("config").and_then(|c| c.get("allow-plugins")),
                global_allow_plugins().as_ref(),
            );
            match plugin_verdict(allow.as_ref(), "composer/installers") {
                PluginVerdict::Allowed => {
                    let version = lock_plugin
                        .map(|p| p.version().to_owned())
                        .or_else(|| {
                            prev_plugin.and_then(|p| p["version"].as_str().map(str::to_owned))
                        })
                        .unwrap_or_default();
                    let Some(t) = installers::table_for(&version) else {
                        return Err(vec![format!(
                            "composer/installers {version} is not a ported version (ported: {})",
                            installers::ported_versions().collect::<Vec<_>>().join(", ")
                        )]);
                    };
                    if has_state && lock_plugin.is_some() != prev_plugin.is_some() {
                        let root_extra = manifest.get("extra");
                        let taken = |name: &str, ty: &str, extra: Option<&Value>| {
                            !matches!(
                                installers::placement(t, root_extra, name, ty, extra),
                                Ok(Placement::Vendor)
                            )
                        };
                        let any_taken = wanted
                            .iter()
                            .any(|p| taken(p.name(), p.package_type(), p.raw.get("extra")))
                            || previous.iter().any(|p| {
                                taken(
                                    p["name"].as_str().unwrap_or(""),
                                    p["type"].as_str().unwrap_or("library"),
                                    p.get("extra"),
                                )
                            });
                        if any_taken {
                            let how = if lock_plugin.is_some() {
                                "added to"
                            } else {
                                "removed from"
                            };
                            return Err(vec![format!(
                                "composer/installers is being {how} an existing install (installed.json and composer.lock disagree): let Composer handle this transition"
                            )]);
                        }
                    }
                    if lock_plugin.is_some() {
                        installers_tag = Some(t.tag.clone());
                        table = Some(t);
                    }
                }
                PluginVerdict::Blocked => {} // Composer ignores it: everything in vendor/
                PluginVerdict::Unlisted => {
                    return Err(vec![
                        "composer/installers is a plugin not covered by config.allow-plugins (Composer would refuse to run it)"
                            .to_owned(),
                    ]);
                }
            }
        }

        // roots/wordpress-core-installer: the same two views must agree
        // (installed.json and the lock), like composer/installers above.
        let wp_lock = wanted.iter().any(|p| p.name() == WP_CORE_PLUGIN);
        let wp_prev = previous
            .iter()
            .any(|p| p["name"].as_str() == Some(WP_CORE_PLUGIN));
        let mut wp_core = false;
        if plugins_enabled && (wp_lock || wp_prev) {
            let allow = merged_allow_plugins(
                manifest.get("config").and_then(|c| c.get("allow-plugins")),
                global_allow_plugins().as_ref(),
            );
            match plugin_verdict(allow.as_ref(), WP_CORE_PLUGIN) {
                PluginVerdict::Allowed => {
                    let any_core = wanted.iter().any(|p| p.package_type() == WP_CORE_TYPE)
                        || previous
                            .iter()
                            .any(|p| p["type"].as_str() == Some(WP_CORE_TYPE));
                    if has_state && wp_lock != wp_prev && any_core {
                        return Err(vec![format!(
                            "{WP_CORE_PLUGIN} is being {} an existing install (installed.json and composer.lock disagree): let Composer handle this transition",
                            if wp_lock { "added to" } else { "removed from" }
                        )]);
                    }
                    wp_core = wp_lock;
                }
                PluginVerdict::Blocked => {}
                PluginVerdict::Unlisted => {
                    return Err(vec![format!(
                        "{WP_CORE_PLUGIN} is a plugin not covered by config.allow-plugins (Composer would refuse to run it)"
                    )]);
                }
            }
        }

        // mnsami/composer-custom-directory-installer: same views rule;
        // with composer/installers also active the installer order
        // follows the plugins' activation order — not reproduced.
        let cd_lock = wanted.iter().any(|p| p.name() == CUSTOM_DIRS_PLUGIN);
        let cd_prev = previous
            .iter()
            .any(|p| p["name"].as_str() == Some(CUSTOM_DIRS_PLUGIN));
        let mut custom_dirs = false;
        if plugins_enabled && (cd_lock || cd_prev) {
            let allow = merged_allow_plugins(
                manifest.get("config").and_then(|c| c.get("allow-plugins")),
                global_allow_plugins().as_ref(),
            );
            match plugin_verdict(allow.as_ref(), CUSTOM_DIRS_PLUGIN) {
                PluginVerdict::Allowed => {
                    if table.is_some() {
                        return Err(vec![format!(
                            "{CUSTOM_DIRS_PLUGIN} together with composer/installers: the installer precedence follows the plugins' activation order (not emulated)"
                        )]);
                    }
                    let root_extra = manifest.get("extra");
                    let mapped = |name: &str, ty: &str, extra: Option<&Value>| {
                        matches!(ty, "library" | "composer-plugin")
                            && custom_dir(root_extra, name, extra).is_some()
                    };
                    let any_mapped = wanted
                        .iter()
                        .any(|p| mapped(p.name(), p.package_type(), p.raw.get("extra")))
                        || previous.iter().any(|p| {
                            mapped(
                                p["name"].as_str().unwrap_or(""),
                                p["type"].as_str().unwrap_or("library"),
                                p.get("extra"),
                            )
                        });
                    if has_state && cd_lock != cd_prev && any_mapped {
                        return Err(vec![format!(
                            "{CUSTOM_DIRS_PLUGIN} is being {} an existing install (installed.json and composer.lock disagree): let Composer handle this transition",
                            if cd_lock { "added to" } else { "removed from" }
                        )]);
                    }
                    custom_dirs = cd_lock;
                }
                PluginVerdict::Blocked => {}
                PluginVerdict::Unlisted => {
                    return Err(vec![format!(
                        "{CUSTOM_DIRS_PLUGIN} is a plugin not covered by config.allow-plugins (Composer would refuse to run it)"
                    )]);
                }
            }
        }

        let root_extra = manifest.get("extra");
        let flex_packs = lock.flex_packs(manifest, with_dev, plugins_enabled);
        let mut paths: BTreeMap<String, String> = BTreeMap::new();
        for p in &wanted {
            if p.is_virtual(flex_packs) {
                continue;
            }
            match place(
                &vendor,
                Placers {
                    table,
                    wp_core,
                    custom_dirs,
                },
                root_extra,
                p.name(),
                p.package_type(),
                p.raw.get("extra"),
                p.target_dir(),
            ) {
                Ok(rel) => {
                    paths.insert(p.name().to_owned(), rel);
                }
                Err(e) => issues.push(e),
            }
        }

        // Conflicting targets: two packages at the same place, or one under the other.
        if table.is_some() || wp_core || custom_dirs {
            let mut by_path: BTreeMap<&str, &str> = BTreeMap::new();
            for (name, rel) in &paths {
                if let Some(other) = by_path.insert(rel.as_str(), name.as_str()) {
                    issues.push(format!("{name} and {other} would both install at `{rel}`"));
                }
            }
            let customs: Vec<(&str, &str)> = paths
                .iter()
                .filter(|(_, rel)| !rel.starts_with(&vendor_prefix))
                .map(|(n, r)| (n.as_str(), r.as_str()))
                .collect();
            for (name, rel) in &customs {
                for (other, other_rel) in &paths {
                    if other.as_str() != *name && other_rel.starts_with(&format!("{rel}/")) {
                        issues.push(format!(
                            "{name} at `{rel}` would contain {other} at `{other_rel}`"
                        ));
                    }
                }
            }
        }

        // Removal plan: Composer recomputes the path of a removed package with
        // the current configuration; we only delete if that path is the one
        // where the package was laid out (installed.json), else fallback.
        let mut removals = BTreeMap::new();
        let wanted_names: std::collections::BTreeSet<&str> =
            wanted.iter().map(|p| p.name()).collect();
        let vendor_composer =
            normalize_path(&format!("{}/{vendor}/composer", root.to_string_lossy()));
        let root_norm = normalize_path(&root.to_string_lossy());
        for prev in &previous {
            let name = prev["name"].as_str().unwrap_or("");
            if name.is_empty() || wanted_names.contains(name) {
                continue;
            }
            let Some(old_ip) = prev.get("install-path").and_then(Value::as_str) else {
                continue; // metapackage
            };
            let old_abs = if crate::pathutil::is_absolute_path(old_ip) {
                normalize_path(old_ip)
            } else {
                normalize_path(&format!("{vendor_composer}/{old_ip}"))
            };
            let Some(old_rel) = old_abs
                .strip_prefix(&format!("{root_norm}/"))
                .filter(|r| !r.is_empty())
            else {
                issues.push(format!(
                    "installed package {name} lives outside the project (`{old_ip}`): not removing it"
                ));
                continue;
            };
            let expected = place(
                &vendor,
                Placers {
                    table,
                    wp_core,
                    custom_dirs,
                },
                root_extra,
                name,
                prev.get("type")
                    .and_then(Value::as_str)
                    .unwrap_or("library"),
                prev.get("extra"),
                prev.get("target-dir")
                    .and_then(Value::as_str)
                    .map(|t| t.trim_matches('/'))
                    .filter(|t| !t.is_empty()),
            );
            match expected {
                Ok(rel) if rel == old_rel => {
                    // LibraryInstaller::removeCode deletes getPackageBasePath:
                    // vendor/<name> without the target-dir.
                    let dir = if rel.starts_with(&vendor_prefix) {
                        format!("{vendor}/{name}")
                    } else {
                        rel
                    };
                    removals.insert(name.to_owned(), dir);
                }
                Ok(rel) => issues.push(format!(
                    "installed package {name} is at `{old_rel}` but the current layout puts it at `{rel}`: let Composer handle this removal"
                )),
                Err(e) => issues.push(format!("removal of {name}: {e}")),
            }
        }

        if issues.is_empty() {
            Ok(Layout {
                root,
                dirs,
                paths,
                installers_tag,
                removals,
            })
        } else {
            Err(issues)
        }
    }

    pub fn root(&self) -> &Path {
        &self.root
    }

    pub fn dirs(&self) -> &Dirs {
        &self.dirs
    }

    /// `<root>/<vendor-dir>` (not canonicalised).
    pub fn vendor_dir(&self) -> PathBuf {
        self.dirs.vendor_dir(&self.root)
    }

    /// `<root>/<bin-dir>`.
    pub fn bin_dir(&self) -> PathBuf {
        self.dirs.bin_dir(&self.root)
    }

    /// `<root>/<vendor-dir>/composer`.
    pub fn composer_dir(&self) -> PathBuf {
        self.dirs.composer_dir(&self.root)
    }

    /// The root package's `install_path` in installed.php: relative to
    /// `<vendor-dir>/composer` like the packages' (`'../../'` by default).
    pub fn root_install_path(&self) -> String {
        let root = self.root.to_string_lossy();
        find_shortest_path(
            &format!("{root}/{}/composer", self.dirs.vendor_rel()),
            &root,
            true,
        )
    }

    /// Project-relative path (None: metapackage or unknown package).
    pub fn rel(&self, name: &str) -> Option<&str> {
        self.paths.get(name).map(String::as_str)
    }

    /// Absolute install path.
    pub fn abs(&self, name: &str) -> Option<PathBuf> {
        self.rel(name).map(|r| self.root.join(r))
    }

    /// Root to empty before laying out the package: `vendor/<name>`
    /// (target-dir included) for LibraryInstaller, the target itself otherwise.
    pub fn package_root(&self, name: &str) -> Option<PathBuf> {
        let rel = self.rel(name)?;
        Some(
            if rel.starts_with(&format!("{}/", self.dirs.vendor_rel())) {
                self.vendor_dir().join(name)
            } else {
                self.root.join(rel)
            },
        )
    }

    /// `install-path` of installed.json / installed.php: relative to
    /// vendor/composer (`findShortestPath($repoDir, $path, true)`).
    pub fn install_path(&self, name: &str) -> Option<String> {
        let rel = self.rel(name)?;
        let root = self.root.to_string_lossy();
        Some(find_shortest_path(
            &format!("{root}/{}/composer", self.dirs.vendor_rel()),
            &format!("{root}/{rel}"),
            true,
        ))
    }

    /// installed.json packages to remove, with their absolute path.
    pub fn removals(&self) -> impl Iterator<Item = (&str, PathBuf)> {
        self.removals
            .iter()
            .map(|(n, rel)| (n.as_str(), self.root.join(rel)))
    }
}

fn installed_packages(root: &Path, dirs: &Dirs) -> Vec<Value> {
    installed_packages_at(&dirs.composer_dir(root))
}

/// The `packages` of `<dir>/installed.json`, raw, or nothing.
pub fn installed_packages_at(composer_dir: &Path) -> Vec<Value> {
    let Some(v) = crate::jsonfile::read(&composer_dir.join("installed.json")) else {
        return Vec::new();
    };
    v.get("packages")
        .and_then(Value::as_array)
        .cloned()
        .unwrap_or_default()
}

/// The project's installed.json packages, raw, under the manifest's
/// vendor-dir (or `vendor/` when that configuration is one the layout
/// refuses — it will say so).
pub fn installed_packages_of(root: &Path, manifest: &Value) -> Vec<Value> {
    let dirs = Dirs::resolve(manifest).unwrap_or_default();
    installed_packages(root, &dirs)
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    fn lock_with(packages: Value) -> Lock {
        Lock::parse(
            &json!({"packages": packages, "packages-dev": [], "plugin-api-version": "2.6.0"})
                .to_string(),
        )
        .expect("lock")
    }

    fn pkg(name: &str, ty: &str, version: &str) -> Value {
        json!({"name": name, "version": version, "type": ty,
               "dist": {"type": "zip", "url": "https://x/y.zip", "reference": "r"}})
    }

    fn root() -> PathBuf {
        // On Windows `/proj` is not absolute (no drive) and would be
        // absolutized under the cwd; an explicit drive keeps the test stable.
        PathBuf::from(if cfg!(windows) { "C:/proj" } else { "/proj" })
    }

    #[test]
    fn allow_plugins_patterns_and_merge() {
        assert!(pattern_matches("composer/*", "composer/installers"));
        assert!(pattern_matches(
            "Composer/Installers",
            "composer/installers"
        ));
        assert!(pattern_matches("*", "anything/here"));
        assert!(!pattern_matches("composer/*", "other/installers"));
        assert!(pattern_matches("*/installers", "composer/installers"));
        let rules = json!({"composer/*": false, "composer/installers": true});
        // First matching rule: `composer/*` -> refused.
        assert_eq!(
            plugin_verdict(Some(&rules), "composer/installers"),
            PluginVerdict::Blocked
        );
        assert_eq!(
            plugin_verdict(Some(&json!(true)), "x/y"),
            PluginVerdict::Allowed
        );
        assert_eq!(
            plugin_verdict(Some(&json!({})), "x/y"),
            PluginVerdict::Unlisted
        );
        assert_eq!(plugin_verdict(None, "x/y"), PluginVerdict::Unlisted);
        let merged = merged_allow_plugins(
            Some(&json!({"a/b": false})),
            Some(&json!({"a/b": true, "c/d": true})),
        );
        assert_eq!(merged, Some(json!({"a/b": false, "c/d": true})));
    }

    #[test]
    fn vendor_dir_moves_every_derived_path() {
        let lock = lock_with(json!([pkg("a/b", "library", "1.0.0")]));
        let manifest = json!({"config": {"vendor-dir": "./lib/vendor/", "bin-dir": "bin"}});
        let l = Layout::resolve(&root(), &lock, &manifest, true, true).expect("layout");
        assert_eq!(l.rel("a/b"), Some("lib/vendor/a/b"));
        assert_eq!(l.abs("a/b"), Some(root().join("lib/vendor/a/b")));
        assert_eq!(
            l.package_root("a/b"),
            Some(root().join("lib/vendor").join("a/b"))
        );
        assert_eq!(l.install_path("a/b").as_deref(), Some("../a/b"));
        assert_eq!(l.root_install_path(), "../../../");
        assert_eq!(l.vendor_dir(), root().join("lib/vendor"));
        assert_eq!(l.bin_dir(), root().join("bin"));
        assert_eq!(l.composer_dir(), root().join("lib/vendor/composer"));
        let l = Layout::resolve(&root(), &lock, &json!({}), true, true).expect("layout");
        assert_eq!(l.root_install_path(), "../../");
        assert_eq!(l.bin_dir(), root().join("vendor/bin"));
        // A refused form is a layout issue, not a silent default.
        let manifest = json!({"config": {"vendor-dir": "../shared/vendor"}});
        let err = Layout::resolve(&root(), &lock, &manifest, true, true).unwrap_err();
        assert!(err[0].contains("outside the project"), "{err:?}");
    }

    #[test]
    fn without_plugin_everything_goes_to_vendor() {
        let lock = lock_with(json!([
            pkg("a/b", "wordpress-plugin", "1.0.0"),
            pkg("a/meta", "metapackage", "1.0.0")
        ]));
        let manifest =
            json!({"extra": {"installer-paths": {"web/{$name}": ["type:wordpress-plugin"]}}});
        let l = Layout::resolve(&root(), &lock, &manifest, true, true).expect("layout");
        assert_eq!(l.rel("a/b"), Some("vendor/a/b"));
        assert_eq!(l.rel("a/meta"), None);
        assert_eq!(l.install_path("a/b").as_deref(), Some("../a/b"));
        assert!(l.installers_tag.is_none());
    }

    #[test]
    fn plugin_allowed_places_packages_and_blocked_keeps_vendor() {
        let lock = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v2.3.0"),
            pkg("wpackagist-plugin/akismet", "wordpress-plugin", "5.3"),
            pkg(
                "wpackagist-theme/twentytwentyfour",
                "wordpress-theme",
                "1.0"
            ),
            pkg("monolog/monolog", "library", "3.0.0"),
            pkg("composer/pcre", "library", "3.0.0"),
        ]));
        let manifest = json!({
            "config": {"allow-plugins": {"composer/installers": true}},
            "extra": {"installer-paths": {"web/app/plugins/{$name}/": ["type:wordpress-plugin"]}}
        });
        let l = Layout::resolve(&root(), &lock, &manifest, true, true).expect("layout");
        assert_eq!(l.installers_tag.as_deref(), Some("v2.3.0"));
        assert_eq!(
            l.rel("wpackagist-plugin/akismet"),
            Some("web/app/plugins/akismet")
        );
        assert_eq!(
            l.rel("wpackagist-theme/twentytwentyfour"),
            Some("wp-content/themes/twentytwentyfour")
        );
        assert_eq!(l.rel("monolog/monolog"), Some("vendor/monolog/monolog"));
        assert_eq!(
            l.rel("composer/installers"),
            Some("vendor/composer/installers")
        );
        assert_eq!(
            l.install_path("wpackagist-plugin/akismet").as_deref(),
            Some("../../web/app/plugins/akismet")
        );
        assert_eq!(l.install_path("composer/pcre").as_deref(), Some("./pcre"));
        assert_eq!(
            l.install_path("monolog/monolog").as_deref(),
            Some("../monolog/monolog")
        );
        assert_eq!(
            l.package_root("wpackagist-plugin/akismet"),
            Some(root().join("web/app/plugins/akismet"))
        );

        let blocked = json!({"config": {"allow-plugins": {"composer/installers": false}}});
        let l = Layout::resolve(&root(), &lock, &blocked, true, true).expect("layout");
        assert_eq!(
            l.rel("wpackagist-plugin/akismet"),
            Some("vendor/wpackagist-plugin/akismet")
        );

        let unlisted = json!({"config": {"allow-plugins": {"other/x": true}}});
        let err = Layout::resolve(&root(), &lock, &unlisted, true, true).expect_err("fallback");
        assert!(err[0].contains("allow-plugins"), "{err:?}");

        let missing = json!({});
        assert!(Layout::resolve(&root(), &lock, &missing, true, true).is_err());
    }

    #[test]
    fn custom_dir_like_package_utils() {
        use serde_json::json;
        let root = json!({"installer-paths": {"modules/Log": ["psr/log"], "lib/{$vendor}-{$name}": ["psr/container", "acme/x"]}});
        assert_eq!(
            custom_dir(Some(&root), "psr/log", None).unwrap(),
            "modules/Log"
        );
        assert_eq!(
            custom_dir(Some(&root), "psr/container", None).unwrap(),
            "lib/psr-container"
        );
        assert_eq!(
            custom_dir(
                Some(&root),
                "acme/x",
                Some(&json!({"installer-name": "renamed"}))
            )
            .unwrap(),
            "lib/acme-renamed"
        );
        assert!(custom_dir(Some(&root), "psr/other", None).is_none());
        assert!(custom_dir(None, "psr/log", None).is_none());
    }

    #[test]
    fn wordpress_core_dir_like_the_plugin() {
        use serde_json::json;
        let d = |root: Option<serde_json::Value>, own: Option<serde_json::Value>| {
            wp_core_dir(
                root.as_ref(),
                "roots/wordpress-no-content",
                own.as_ref(),
                "vendor",
            )
        };
        assert_eq!(d(None, None).unwrap(), "wordpress");
        assert_eq!(
            d(Some(json!({"wordpress-install-dir": "web/wp"})), None).unwrap(),
            "web/wp"
        );
        // A map by pretty name; a missing or empty entry falls through.
        assert_eq!(
            d(
                Some(json!({"wordpress-install-dir": {"roots/wordpress-no-content": "cms"}})),
                None
            )
            .unwrap(),
            "cms"
        );
        assert_eq!(
            d(
                Some(json!({"wordpress-install-dir": {"other/pkg": "cms"}})),
                Some(json!({"wordpress-install-dir": "own"}))
            )
            .unwrap(),
            "own"
        );
        // PHP `empty()`: "" and "0" do not count.
        assert_eq!(
            d(Some(json!({"wordpress-install-dir": ""})), None).unwrap(),
            "wordpress"
        );
        assert!(d(Some(json!({"wordpress-install-dir": "."})), None)
            .unwrap_err()
            .contains("invalid WordPress install directory"));
        assert!(d(Some(json!({"wordpress-install-dir": "vendor"})), None).is_err());
    }

    #[test]
    fn unported_version_custom_framework_and_dangerous_targets_are_issues() {
        let manifest = json!({"config": {"allow-plugins": true}});
        let old = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v1.12.0"),
            pkg("a/b", "drupal-module", "1.0")
        ]));
        let err = Layout::resolve(&root(), &old, &manifest, true, true).expect_err("v1");
        assert!(err[0].contains("not a ported version"), "{err:?}");

        let cake = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v2.2.0"),
            pkg("a/b", "cakephp-plugin", "1.0")
        ]));
        let err = Layout::resolve(&root(), &cake, &manifest, true, true).expect_err("cake");
        assert!(err[0].contains("custom path logic"), "{err:?}");

        let lock = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v2.3.0"),
            pkg("a/b", "drupal-module", "1.0"),
            pkg("a/c", "drupal-module", "1.0")
        ]));
        for (paths, needle) in [
            (json!({"{$name}/../../x": ["a/b"]}), "outside the project"),
            (json!({"vendor/{$name}": ["a/b"]}), "inside vendor/"),
            (json!({"/abs/{$name}": ["a/b"]}), "absolute path"),
            (json!({"same/": ["a/b", "a/c"]}), "would both install"),
            (json!({"modules/": ["a/b"]}), "would contain"),
        ] {
            let m = json!({"config": {"allow-plugins": true}, "extra": {"installer-paths": paths}});
            let err = Layout::resolve(&root(), &lock, &m, true, true).expect_err(needle);
            assert!(err.iter().any(|e| e.contains(needle)), "{needle}: {err:?}");
        }
        // The root project: empty template.
        let m =
            json!({"config": {"allow-plugins": true}, "extra": {"installer-paths": {"": ["a/b"]}}});
        let err = Layout::resolve(&root(), &lock, &m, true, true).expect_err("root");
        assert!(err.iter().any(|e| e.contains("project root")), "{err:?}");
    }

    #[test]
    fn removals_follow_installed_json_when_paths_agree() {
        let dir = tempfile::tempdir().expect("tmp");
        let vc = dir.path().join("vendor/composer");
        std::fs::create_dir_all(&vc).expect("mkdir");
        let plugin_entry = json!({"name": "composer/installers", "version": "v2.3.0", "type": "composer-plugin", "install-path": "./installers"});
        std::fs::write(
            vc.join("installed.json"),
            json!({"packages": [
                plugin_entry,
                {"name": "gone/lib", "version": "1.0", "type": "library", "install-path": "../gone/lib"},
                {"name": "gone/legacy", "version": "1.0", "type": "library", "target-dir": "Acme/Legacy", "install-path": "../gone/legacy/Acme/Legacy"},
                {"name": "gone/plugin", "version": "1.0", "type": "wordpress-plugin", "install-path": "../../wp-content/plugins/plugin"},
                {"name": "moved/plugin", "version": "1.0", "type": "wordpress-plugin", "install-path": "../../old/plugin"},
                {"name": "gone/meta", "version": "1.0", "type": "metapackage", "install-path": null}
            ], "dev": true, "dev-package-names": []})
            .to_string(),
        )
        .expect("write");
        let lock = lock_with(json!([pkg(
            "composer/installers",
            "composer-plugin",
            "v2.3.0"
        )]));
        let manifest = json!({"config": {"allow-plugins": true}});
        let err = Layout::resolve(dir.path(), &lock, &manifest, true, true).expect_err("moved");
        assert!(
            err.iter()
                .any(|e| e.contains("moved/plugin") && e.contains("old/plugin")),
            "{err:?}"
        );

        // Without the moved package, the plan is accepted; a target-dir package
        // is deleted at vendor/<name> (getPackageBasePath), not at the sub-path.
        std::fs::write(
            vc.join("installed.json"),
            json!({"packages": [
                plugin_entry,
                {"name": "gone/lib", "version": "1.0", "type": "library", "install-path": "../gone/lib"},
                {"name": "gone/legacy", "version": "1.0", "type": "library", "target-dir": "Acme/Legacy", "install-path": "../gone/legacy/Acme/Legacy"},
                {"name": "gone/plugin", "version": "1.0", "type": "wordpress-plugin", "install-path": "../../wp-content/plugins/plugin"}
            ], "dev": true, "dev-package-names": []})
            .to_string(),
        )
        .expect("write");
        let l = Layout::resolve(dir.path(), &lock, &manifest, true, true).expect("layout");
        let removals: Vec<(String, PathBuf)> =
            l.removals().map(|(n, p)| (n.to_owned(), p)).collect();
        assert_eq!(
            removals,
            vec![
                (
                    "gone/legacy".to_owned(),
                    l.root().join("vendor/gone/legacy")
                ),
                ("gone/lib".to_owned(), l.root().join("vendor/gone/lib")),
                (
                    "gone/plugin".to_owned(),
                    l.root().join("wp-content/plugins/plugin")
                ),
            ]
        );
    }

    #[test]
    fn plugin_present_on_one_side_only_is_a_transition_for_composer() {
        let dir = tempfile::tempdir().expect("tmp");
        let vc = dir.path().join("vendor/composer");
        std::fs::create_dir_all(&vc).expect("mkdir");
        let manifest = json!({"config": {"allow-plugins": true}});
        let with_plugin = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v2.3.0"),
            pkg("a/wp", "wordpress-plugin", "1.0"),
        ]));
        let without_plugin = lock_with(json!([pkg("a/wp", "wordpress-plugin", "1.0")]));
        let libs_only = lock_with(json!([
            pkg("composer/installers", "composer-plugin", "v2.3.0"),
            pkg("a/lib", "library", "1.0"),
        ]));

        // Addition: installed.json without the plugin, lock with it, and an affected package.
        std::fs::write(
            vc.join("installed.json"),
            json!({"packages": [{"name": "a/wp", "version": "1.0", "type": "wordpress-plugin", "install-path": "../a/wp"}], "dev": true, "dev-package-names": []}).to_string(),
        )
        .expect("write");
        let err =
            Layout::resolve(dir.path(), &with_plugin, &manifest, true, true).expect_err("added");
        assert!(err[0].contains("added to an existing install"), "{err:?}");
        // Same addition without a package of a type taken by the plugin: nothing to transition.
        std::fs::write(
            vc.join("installed.json"),
            json!({"packages": [{"name": "a/lib", "version": "1.0", "type": "library", "install-path": "../a/lib"}], "dev": true, "dev-package-names": []}).to_string(),
        )
        .expect("write");
        assert!(Layout::resolve(dir.path(), &libs_only, &manifest, true, true).is_ok());

        // Removal: installed.json with the plugin and a package outside vendor/, lock without.
        std::fs::write(
            vc.join("installed.json"),
            json!({"packages": [
                {"name": "composer/installers", "version": "v2.3.0", "type": "composer-plugin", "install-path": "./installers"},
                {"name": "a/wp", "version": "1.0", "type": "wordpress-plugin", "install-path": "../../wp-content/plugins/wp"}
            ], "dev": true, "dev-package-names": []}).to_string(),
        )
        .expect("write");
        let err = Layout::resolve(dir.path(), &without_plugin, &manifest, true, true)
            .expect_err("removed");
        assert!(
            err[0].contains("removed from an existing install"),
            "{err:?}"
        );

        // --no-plugins: Composer ignores the plugin on both sides, everything in vendor/.
        let l =
            Layout::resolve(dir.path(), &with_plugin, &manifest, true, false).expect("no-plugins");
        assert_eq!(l.rel("a/wp"), Some("vendor/a/wp"));
        assert!(l.installers_tag.is_none());
        // No on-disk state: the lock decides (fresh install).
        std::fs::remove_file(vc.join("installed.json")).expect("rm");
        let l = Layout::resolve(dir.path(), &with_plugin, &manifest, true, true).expect("fresh");
        assert_eq!(l.rel("a/wp"), Some("wp-content/plugins/wp"));
    }
}