mod extension_installers;
mod flex;
mod require;
mod scripts;
use anyhow::Context as _;
use clap::Parser;
use std::path::PathBuf;
use std::sync::Arc;
#[derive(Parser, Debug)]
#[command(
name = "vivacity",
version,
about = "Fast, Composer-compatible installer"
)]
enum Cli {
Install(InstallArgs),
#[command(name = "dump-autoload", alias = "dumpautoload")]
DumpAutoload(DumpArgs),
#[command(alias = "upgrade")]
Update(UpdateArgs),
#[command(alias = "rm")]
Remove(RemoveArgs),
#[command(alias = "r")]
Require(RequireArgs),
}
#[derive(clap::Args, Debug)]
struct RequireArgs {
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long)]
dev: bool,
#[arg(long)]
dry_run: bool,
#[arg(long)]
prefer_source: bool,
#[arg(long)]
prefer_dist: bool,
#[arg(long)]
prefer_install: Option<String>,
#[arg(long)]
fixed: bool,
#[arg(long)]
no_suggest: bool,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_update: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
no_audit: bool,
#[arg(long, value_name = "FORMAT")]
audit_format: Option<String>,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
update_no_dev: bool,
#[arg(short = 'w', long)]
update_with_dependencies: bool,
#[arg(long)]
with_dependencies: bool,
#[arg(short = 'W', long)]
update_with_all_dependencies: bool,
#[arg(long)]
with_all_dependencies: bool,
#[arg(short = 'm', long)]
minimal_changes: bool,
#[arg(long)]
prefer_stable: bool,
#[arg(long)]
prefer_lowest: bool,
#[arg(long)]
sort_packages: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(short = 'n', long)]
no_interaction: bool,
#[arg(short = 'q', long)]
quiet: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
verbose: u8,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
}
#[derive(clap::Args, Debug)]
struct RemoveArgs {
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long)]
dev: bool,
#[arg(long)]
no_update: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
no_audit: bool,
#[arg(long)]
update_no_dev: bool,
#[arg(short = 'w', long)]
update_with_dependencies: bool,
#[arg(short = 'W', long)]
update_with_all_dependencies: bool,
#[arg(long)]
with_all_dependencies: bool,
#[arg(long)]
no_update_with_dependencies: bool,
#[arg(long)]
unused: bool,
#[arg(long)]
dry_run: bool,
#[arg(short = 'm', long)]
minimal_changes: bool,
#[arg(short = 'n', long)]
no_interaction: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long, value_name = "FORMAT")]
audit_format: Option<String>,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(short = 'q', long)]
quiet: bool,
#[arg(short = 'v', long, action = clap::ArgAction::Count)]
verbose: u8,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
}
#[derive(clap::Args, Debug)]
struct UpdateArgs {
#[arg(long)]
no_progress: bool,
#[arg(value_name = "PACKAGES")]
packages: Vec<String>,
#[arg(long = "with", value_name = "REQ")]
with: Vec<String>,
#[arg(short = 'w', long)]
with_dependencies: bool,
#[arg(short = 'W', long)]
with_all_dependencies: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
dry_run: bool,
#[arg(long)]
no_dev: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
no_audit: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
prefer_stable: bool,
#[arg(long)]
prefer_lowest: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
offline: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
#[arg(skip)]
spawn_fallback: bool,
}
#[derive(clap::Args, Debug)]
struct DumpArgs {
#[arg(long)]
no_dev: bool,
#[arg(short = 'o', long)]
optimize: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long = "apcu")]
apcu_autoloader: bool,
#[arg(long = "apcu-prefix", value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
run_scripts: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
}
#[derive(clap::Args, Debug)]
struct InstallArgs {
#[arg(long)]
no_dev: bool,
#[arg(long)]
prefer_source: bool,
#[arg(long)]
prefer_dist: bool,
#[arg(long, value_name = "PREFER-INSTALL")]
prefer_install: Option<String>,
#[arg(long)]
no_progress: bool,
#[arg(long)]
no_autoloader: bool,
#[arg(short = 'o', long)]
optimize_autoloader: bool,
#[arg(short = 'a', long)]
classmap_authoritative: bool,
#[arg(long)]
apcu_autoloader: bool,
#[arg(long, value_name = "PREFIX")]
apcu_autoloader_prefix: Option<String>,
#[arg(long)]
no_scripts: bool,
#[arg(long)]
run_scripts: bool,
#[arg(long)]
no_plugins: bool,
#[arg(long)]
ignore_platform_reqs: bool,
#[arg(long = "ignore-platform-req", value_name = "REQ")]
ignore_platform_req: Vec<String>,
#[arg(long)]
no_fallback: bool,
#[arg(long)]
check_scope: bool,
#[arg(long)]
offline: bool,
#[arg(long)]
no_blocking: bool,
#[arg(long)]
no_security_blocking: bool,
#[arg(long)]
no_install: bool,
#[arg(long)]
dry_run: bool,
#[arg(long, value_name = "DIR")]
working_dir: Option<PathBuf>,
#[arg(skip)]
#[cfg_attr(not(unix), allow(dead_code))]
spawn_fallback: bool,
#[arg(skip)]
after_update: bool,
#[arg(skip)]
virtual_lock: Option<serde_json::Value>,
#[arg(skip)]
virtual_manifest: Option<serde_json::Value>,
}
fn trace(label: &str, since: std::time::Instant) {
if std::env::var_os("VIVACITY_TRACE").is_some() {
eprintln!(
"trace: {label:<22} {:>7.1} ms",
since.elapsed().as_secs_f64() * 1000.0
);
}
}
pub fn run<I, T>(args: I) -> i32
where
I: IntoIterator<Item = T>,
T: Into<std::ffi::OsString> + Clone,
{
let argv: Vec<std::ffi::OsString> = args.into_iter().map(Into::into).collect();
if let Ok(mut a) = ARGV.lock() {
*a = argv.clone();
}
let cli = match Cli::try_parse_from(argv) {
Ok(cli) => cli,
Err(e) => {
let _ = e.print();
return e.exit_code();
}
};
match dispatch(cli) {
Ok(code) => code,
Err(e) => {
eprintln!("Error: {e:?}");
1
}
}
}
static ARGV: std::sync::Mutex<Vec<std::ffi::OsString>> = std::sync::Mutex::new(Vec::new());
fn resolution_fallback(
project: &std::path::Path,
manifest: &serde_json::Value,
command: vivacity_core::scope::ResolutionCommand,
no_plugins: bool,
no_fallback: bool,
with_install: bool,
) -> anyhow::Result<Option<i32>> {
let mut issues = vivacity_core::scope::resolution_issues(
project,
manifest,
command,
!no_plugins,
with_install,
);
let flex_active = vivacity_core::scope::active_plugins(project, manifest, !no_plugins)
.iter()
.any(|p| p == "symfony/flex");
if flex_active && !issues.iter().any(|i| matches!(i, vivacity_core::scope::ScopeIssue::ResolutionPlugin(n, _) if n == "symfony/flex")) {
if let Some(reason) = flex_write_guard(project, manifest) {
issues.push(vivacity_core::scope::ScopeIssue::ResolutionPlugin(
"symfony/flex".to_owned(),
reason,
));
}
}
let merge_active = vivacity_core::scope::active_plugins(project, manifest, !no_plugins)
.iter()
.any(|p| p == vivacity_resolver::merge_plugin::PLUGIN_NAME);
if merge_active {
if let Ok(Some(merged)) = merge_root_when(project, manifest, true, true) {
if !merged.repositories.is_empty() {
issues.push(vivacity_core::scope::ScopeIssue::ResolutionPlugin(
vivacity_resolver::merge_plugin::PLUGIN_NAME.to_owned(),
format!(
"merges repositories from {} (not emulated at resolution)",
merged.repositories.join(", ")
),
));
}
}
}
if issues.is_empty() {
return Ok(None);
}
delegate_resolution(project, command, &issues, no_fallback).map(Some)
}
fn delegate_resolution(
project: &std::path::Path,
command: vivacity_core::scope::ResolutionCommand,
issues: &[vivacity_core::scope::ScopeIssue],
no_fallback: bool,
) -> anyhow::Result<i32> {
eprintln!(
"vivacity: `{}` on this project is outside what vivacity handles natively:",
command.name()
);
for issue in issues {
eprintln!(" - {issue}");
}
if no_fallback {
eprintln!("--no-fallback given: stopping here (nothing was written).");
return Ok(3);
}
let Some(composer) = which_composer() else {
eprintln!(
"composer not found for the fallback — install Composer or run with --no-plugins."
);
return Ok(3);
};
let argv = ARGV.lock().map(|a| a.clone()).unwrap_or_default();
let forwarded: Vec<std::ffi::OsString> = argv
.iter()
.skip(1)
.filter(|a| a.to_string_lossy() != "--no-fallback" && a.to_string_lossy() != "--offline")
.cloned()
.collect();
let mut forwarded = forwarded;
if !forwarded.iter().any(|a| a == "--no-scripts") {
forwarded.push("--no-scripts".into());
}
eprintln!(
"vivacity: delegating to `composer {}`…",
forwarded
.iter()
.map(|a| a.to_string_lossy().into_owned())
.collect::<Vec<_>>()
.join(" ")
);
let mut cmd = std::process::Command::new(composer);
cmd.args(&forwarded).current_dir(project);
let status = cmd.status().context("cannot run composer")?;
Ok(status.code().unwrap_or(1))
}
fn dispatch(cli: Cli) -> anyhow::Result<i32> {
match cli {
Cli::Install(args) => run_install(&args),
Cli::DumpAutoload(args) => run_dump(&args),
Cli::Update(args) => run_update(&args),
Cli::Remove(args) => run_remove(&args),
Cli::Require(args) => require::run_require(&args),
}
}
fn project_dir(working_dir: Option<&std::path::Path>) -> anyhow::Result<PathBuf> {
let cwd = std::env::current_dir().context("cannot determine the current directory")?;
Ok(match working_dir {
Some(d) if d.is_absolute() => d.to_path_buf(),
Some(d) => cwd.join(d),
None => cwd,
})
}
fn run_install(args: &InstallArgs) -> anyhow::Result<i32> {
if args.no_install {
eprintln!("Invalid option \"--no-install\". Use \"composer update --no-install\" instead if you are trying to update the composer.lock file.");
return Ok(1);
}
let t0 = std::time::Instant::now();
let project = project_dir(args.working_dir.as_deref())?;
let manifest_path = project.join("composer.json");
let lock_path = project.join("composer.lock");
refuse_alternate_manifest()?;
let manifest_text = std::fs::read_to_string(&manifest_path)
.with_context(|| format!("cannot read {}", manifest_path.display()))?;
let manifest: serde_json::Value = match &args.virtual_manifest {
Some(v) => v.clone(),
None => serde_json::from_str(&manifest_text).context("invalid composer.json")?,
};
if let Some(code) = refuse_invalid_root(&manifest) {
return Ok(code);
}
let mut manifest = manifest;
match vivacity_core::scope::effective_preferred_install(
&manifest,
args.prefer_source,
args.prefer_dist,
args.prefer_install.as_deref(),
) {
Err(message) => {
eprintln!("{message}");
return Ok(1);
}
Ok(Some(value)) => {
if let Some(config) = manifest.get_mut("config").and_then(|c| c.as_object_mut()) {
config.insert("preferred-install".to_owned(), value);
} else if let Some(root) = manifest.as_object_mut() {
root.insert(
"config".to_owned(),
serde_json::json!({"preferred-install": value}),
);
}
}
Ok(None) => {}
}
let manifest = manifest;
if args.virtual_lock.is_none() && !lock_path.is_file() {
anyhow::bail!(
"no composer.lock in {} — `install` needs one; run `vivacity update` \
to resolve and write it (Composer's `install` resolves instead, \
which vivacity does not do)",
project.display()
);
}
let lock_text: String = match &args.virtual_lock {
Some(v) => {
vivacity_core::phpjson::php_json_encode_with(v, vivacity_core::phpjson::FLAGS_JSONFILE)?
}
None => std::fs::read_to_string(&lock_path)
.with_context(|| format!("cannot read {}", lock_path.display()))?,
};
let lock_value: serde_json::Value =
serde_json::from_str(&lock_text).context("invalid composer.lock")?;
let lock = vivacity_core::lock::Lock::from_value(&lock_value);
trace("read manifests", t0);
let with_dev = !args.no_dev && std::env::var("COMPOSER_NO_DEV").as_deref() != Ok("1");
let merged = match merge_plugin_root(&project, &lock, &manifest, with_dev, !args.no_plugins) {
Ok(m) => m,
Err(reason) => {
let report = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::MergePlugin(reason)],
..Default::default()
};
return fallback_or_fail(args, &project, &report);
}
};
let manifest = match &merged {
Some(m) => m.manifest.clone(),
None => manifest,
};
let runner = if args.run_scripts && !args.no_scripts {
match scripts::Runner::new(&project, &manifest, with_dev, which_composer()) {
Ok(r) => r,
Err(e) => {
eprintln!("vivacity: {e}");
return Ok(3);
}
}
} else {
None
};
if let Some(r) = &runner {
let code = r.run(scripts::PRE_INSTALL_CMD)?;
if code != 0 {
return Ok(code);
}
}
if vivacity_core::scope::active_plugins(&project, &manifest, !args.no_plugins)
.iter()
.any(|p| p == vivacity_core::bamarni_bin::PLUGIN_NAME)
{
if let Ok(cfg) = vivacity_core::bamarni_bin::config(manifest.get("extra")) {
vivacity_core::bamarni_bin::print_deprecations(&cfg);
}
}
let config_lock = config_lock_enabled(&manifest_text);
if config_lock {
eprintln!(
"Installing dependencies from lock file{}",
if with_dev {
" (including require-dev)"
} else {
""
}
);
}
if !args.after_update {
eprintln!("Verifying lock file contents can be installed on current platform.");
if let (Ok(actual), Some(expected)) = (
vivacity_core::content_hash::content_hash(&manifest_text),
lock.content_hash.as_deref(),
) {
if actual != expected {
eprintln!(
"Warning: The lock file is not up to date with the latest changes in composer.json. \
You may be getting outdated dependencies. It is recommended that you run `composer update` or `composer update <package name>`."
);
}
}
}
let policy_thread = if args.after_update {
None
} else {
let http = http_transport(&project, args.offline)?;
let cache_repo_dir = vivacity_core::fetch::composer_cache_dir().join("repo");
let composer_home = vivacity_core::fetch::composer_home();
let project_dir = project.clone();
let no_blocking = args.no_blocking || args.no_security_blocking;
Some(std::thread::spawn(move || {
vivacity_resolver::session::install_policy_problems(
&project_dir,
composer_home.as_deref(),
Some(http),
Some(&cache_repo_dir),
with_dev,
no_blocking,
)
.map_err(|e| anyhow::anyhow!("{e}"))
}))
};
let mut ignored = args.ignore_platform_req.clone();
if args.ignore_platform_reqs {
ignored.push("*".to_owned());
}
let platform_outcome: PlatformOutcome = if ignored.iter().all(|p| p != "*") {
match vivacity_resolver::platform::probe().ok() {
Some(probed) => {
let empty = serde_json::Map::new();
let overrides = manifest
.get("config")
.and_then(|c| c.get("platform"))
.and_then(serde_json::Value::as_object)
.unwrap_or(&empty);
let platform = vivacity_resolver::platform::platform_packages(&probed, overrides)
.map_err(|e| anyhow::anyhow!("{}", e.0))?;
PlatformOutcome::Failures(vivacity_resolver::platform::check_install(
&lock, &platform, with_dev, &ignored,
))
}
None => PlatformOutcome::NoPhp {
warn: !lock.platform.is_empty() || (with_dev && !lock.platform_dev.is_empty()),
},
}
} else {
PlatformOutcome::Failures(Vec::new())
};
trace("platform check", t0);
let mut arena: Vec<vivacity_resolver::package::Package> = Vec::new();
let installed_now = installed_packages(&project, &manifest);
trace("installed.json", t0);
let unchanged_names = unchanged_local_repository(&installed_now, &lock_value, with_dev);
let (present, result) = if unchanged_names.is_some() {
(Vec::new(), Vec::new())
} else {
let as_lock = serde_json::json!({"packages": installed_now, "packages-dev": []});
let present =
vivacity_resolver::repository::locked_repository_with(&as_lock, &mut arena, true)
.map_err(|e| anyhow::anyhow!("installed.json: {}", e.0))?;
let result = vivacity_resolver::repository::locked_repository_with(
&lock_value,
&mut arena,
with_dev,
)
.map_err(|e| anyhow::anyhow!("composer.lock: {}", e.0))?;
(present, result)
};
let merged_links = merged
.as_ref()
.map(|m| (m.requires.as_slice(), m.requires_dev.as_slice()));
let root_pkg = vivacity_core::state::RootPackage::detect(&manifest, &project, with_dev);
let missing = missing_requirement_info(
&manifest,
&lock_value,
with_dev,
&root_pkg.version,
&root_pkg.pretty_version,
merged_links,
)?;
trace("local repositories", t0);
let transaction = vivacity_resolver::transaction::Transaction::new(&arena, &present, &result);
let scope = if args.dry_run {
None
} else {
Some(vivacity_core::scope::analyze(
&project,
&lock,
&manifest,
with_dev,
!args.no_plugins,
))
};
trace("scope analysis", t0);
let early_dump: Option<anyhow::Result<PlannedDump>> = if args.dry_run
|| args.no_autoloader
|| runner.is_some()
|| !transaction.operations.is_empty()
{
None
} else {
scope
.as_ref()
.filter(|s| s.is_native_ok())
.and_then(|s| s.layout.as_ref())
.and_then(|layout| {
vivacity_core::installer::local_repository_if_unchanged(&lock, layout, with_dev)
.map(|local| {
dump_autoload_plan(
&project,
&local,
&manifest,
layout,
with_dev,
args.optimize_autoloader || args.classmap_authoritative,
args.classmap_authoritative,
args.ignore_platform_reqs,
&args.ignore_platform_req,
(args.apcu_autoloader, args.apcu_autoloader_prefix.as_deref()),
!args.no_plugins,
lock.packages_dev
.iter()
.map(|p| p.name().to_owned())
.collect(),
)
})
})
};
trace("autoload planned", t0);
if let Some(handle) = policy_thread {
let (problems, warnings) = handle
.join()
.map_err(|_| anyhow::anyhow!("the policy check thread panicked"))??;
for w in &warnings {
eprintln!("{w}");
}
if !problems.is_empty() {
eprintln!("Your lock file does not contain a compatible set of packages. Please run composer update.");
let mut text = String::from("\n");
let mut seen: Vec<&String> = Vec::new();
for p in &problems {
if seen.contains(&p) {
continue;
}
seen.push(p);
text.push_str(&format!(" Problem {}\n {p}\n", seen.len()));
}
eprintln!("{text}");
return Ok(2);
}
trace("policy", t0);
}
match platform_outcome {
PlatformOutcome::Failures(failures) if !failures.is_empty() => {
eprintln!("Your lock file cannot be installed on this platform:");
for f in &failures {
let by = f
.required_by
.as_deref()
.map(|p| format!(" (required by {p})"))
.unwrap_or_default();
eprintln!(
" - {} {}{}: {:?}",
f.requirement, f.constraint, by, f.reason
);
}
eprintln!("Use --ignore-platform-req=<req> or --ignore-platform-reqs to bypass.");
return Ok(4);
}
PlatformOutcome::NoPhp { warn: true } => {
eprintln!(
"Warning: php not found, platform requirements were not checked \
(--ignore-platform-reqs silences this warning)"
);
}
_ => {}
}
if !missing.is_empty() {
if let Some(m) = &merged {
let plugin_installed = installed_packages(&project, &manifest).iter().any(|p| {
p.get("name").and_then(|n| n.as_str())
== Some(vivacity_resolver::merge_plugin::PLUGIN_NAME)
});
if !plugin_installed {
let report = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::MergePlugin(format!(
"the lock does not satisfy the merged requirements ({}); Composer would run the plugin's implicit update and rewrite composer.lock",
m.merged_names.join(", ")
))],
..Default::default()
};
return fallback_or_fail(args, &project, &report);
}
}
for line in &missing {
eprintln!("{line}");
}
if !require::truthy(require::config_value(
&manifest,
"allow-missing-requirements",
)) {
return Ok(4);
}
}
{
use vivacity_resolver::transaction::Operation;
let ops = &transaction.operations;
let installs = ops
.iter()
.filter(|o| matches!(o, Operation::Install(_)))
.count();
let updates = ops
.iter()
.filter(|o| matches!(o, Operation::Update(..)))
.count();
let removals = ops
.iter()
.filter(|o| matches!(o, Operation::Uninstall(_)))
.count();
if installs + updates + removals == 0 {
eprintln!("Nothing to install, update or remove");
} else {
eprintln!(
"Package operations: {installs} install{}, {updates} update{}, {removals} removal{}",
if installs == 1 { "" } else { "s" },
if updates == 1 { "" } else { "s" },
if removals == 1 { "" } else { "s" }
);
}
}
if args.dry_run {
for op in &transaction.operations {
if let Some(line) = op.show(&arena, false) {
eprintln!(" - {line}");
}
}
if !args.after_update {
for line in abandoned_warnings(&lock_value) {
eprintln!("{line}");
}
print_funding(&project, &manifest);
}
return Ok(0);
}
let Some(scope) = scope else {
anyhow::bail!("internal: scope was not analysed");
};
if !scope.is_native_ok() {
return fallback_or_fail(args, &project, &scope);
}
let Some(layout) = scope.layout.as_ref() else {
anyhow::bail!("internal: scope is native but no layout was resolved");
};
if let Some(tag) = &layout.installers_tag {
eprintln!("Note: composer/installers {tag} emulated natively (custom install paths)");
}
for plugin in &scope.skipped_plugins {
eprintln!(
"Note: plugin {plugin} installed as a plain library (vivacity never runs plugins)"
);
}
trace("scope", t0);
if args.check_scope {
eprintln!("vivacity: this lock is installed natively");
return Ok(0);
}
let operation_lines = operation_lines(
&project,
&arena,
&transaction.operations,
layout,
lock.flex_packs(&manifest, with_dev, !args.no_plugins),
!args.no_plugins,
)?;
let downloading = download_lines(&lock, &arena, &transaction.operations, with_dev);
let store = Arc::new(vivacity_core::store::Store::default_location());
let auth = vivacity_core::fetch::Auth::load(&project);
let fetcher = Arc::new(vivacity_core::fetch::Fetcher::new(
vivacity_core::fetch::composer_cache_dir(),
auth,
)?);
let opts = vivacity_core::installer::InstallOptions {
with_dev,
offline: args.offline,
plugins_enabled: !args.no_plugins,
..Default::default()
};
let runtime = tokio::runtime::Runtime::new().context("cannot start the async runtime")?;
let report = match runtime.block_on(vivacity_core::installer::install(
&project, &lock, &manifest, layout, store, fetcher, &opts,
)) {
Ok(r) => r,
Err(vivacity_core::Error::Unsupported(msg)) => {
let scope = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(msg)],
skipped_plugins: vec![],
layout: None,
};
return fallback_or_fail(args, &project, &scope);
}
Err(vivacity_core::Error::Refused(msg)) => {
eprintln!("{msg}");
return Ok(1);
}
Err(e) => return Err(e.into()),
};
trace("install transaction", t0);
for line in &downloading {
eprintln!("{line}");
}
for line in &operation_lines {
eprintln!("{line}");
}
for m in &report.messages {
eprintln!("{m}");
}
if !args.after_update {
for line in abandoned_warnings(&lock_value) {
eprintln!("{line}");
}
}
let mut autoload_note = String::new();
if !args.no_autoloader {
if let Some(r) = &runner {
let code = r.run(scripts::PRE_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(code);
}
}
eprintln!(
"Generating{} autoload files",
if effective_optimize(
&manifest,
args.optimize_autoloader,
args.classmap_authoritative
) {
" optimized"
} else {
""
}
);
let local = report.local_repository.as_ref().unwrap_or(&lock);
let planned = match early_dump {
Some(planned) => planned?,
None => dump_autoload_plan(
&project,
local,
&manifest,
layout,
with_dev,
args.optimize_autoloader || args.classmap_authoritative,
args.classmap_authoritative,
args.ignore_platform_reqs,
&args.ignore_platform_req,
(args.apcu_autoloader, args.apcu_autoloader_prefix.as_deref()),
!args.no_plugins,
lock.packages_dev
.iter()
.map(|p| p.name().to_owned())
.collect(),
)?,
};
let report = planned.finish(&project, &manifest, layout)?;
autoload_note = format!(", autoloader with {} classes", report.classes);
{
use vivacity_resolver::transaction::Operation;
let previous: Vec<&str> = match &unchanged_names {
Some(names) => names.iter().map(String::as_str).collect(),
None => present.iter().map(|&i| arena[i].name.as_str()).collect(),
};
let mut gone: Vec<&str> = Vec::new();
let mut fresh: Vec<&str> = Vec::new();
for op in &transaction.operations {
match *op {
Operation::Uninstall(p) => gone.push(arena[p].name.as_str()),
Operation::Update(i, t) => {
gone.push(arena[i].name.as_str());
fresh.push(arena[t].name.as_str());
}
Operation::Install(p) => fresh.push(arena[p].name.as_str()),
_ => {}
}
}
let order =
vivacity_core::pest_plugin::local_repository_order(&previous, &gone, &fresh);
let previously_present = previous.contains(&vivacity_core::pest_plugin::PLUGIN_NAME);
emulate_pest_plugin(
&project,
local,
&manifest,
with_dev,
&order,
!args.no_plugins,
previously_present,
)?;
let touched: Vec<&str> = gone.iter().chain(fresh.iter()).copied().collect();
emulate_yii2_composer(
&project,
local,
&manifest,
with_dev,
&order,
&touched,
!args.no_plugins,
)?;
emulate_c3(
&project,
local,
&manifest,
with_dev,
previous.contains(&vivacity_core::c3_plugin::PLUGIN_NAME),
args.after_update,
!args.no_plugins,
)?;
emulate_bamarni_bin(local, &manifest, with_dev, !args.no_plugins);
emulate_package_versions(&project, local, &manifest, with_dev, !args.no_plugins)?;
}
if let Some(r) = &runner {
let code = r.run(scripts::POST_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(code);
}
}
trace("autoload dump", t0);
}
if !args.no_plugins {
let local = report.local_repository.as_ref().unwrap_or(&lock);
let installed: Vec<&vivacity_core::lock::LockPackage> =
local.wanted_packages(with_dev).collect();
let allowed = matches!(
vivacity_core::layout::plugin_allowed(
&manifest,
vivacity_core::phpcs_installer::PLUGIN_NAME
),
vivacity_core::layout::PluginVerdict::Allowed
);
if allowed
&& installed
.iter()
.any(|p| p.name() == vivacity_core::phpcs_installer::PLUGIN_NAME)
{
vivacity_core::phpcs_installer::register_standards(
&project, layout, &installed, &manifest,
)?;
}
extension_installers::phpstan(layout, local, &manifest, with_dev, !args.no_plugins)?;
extension_installers::rector(layout, local, &manifest, with_dev, !args.no_plugins)?;
}
if !args.after_update {
print_funding(&project, &manifest);
emulate_flex_install(&project, &manifest, !args.no_plugins)?;
}
if let Some(r) = &runner {
let code = r.run(scripts::POST_INSTALL_CMD)?;
if code != 0 {
return Ok(code);
}
}
let warmed = if report.store_warmed > 0 {
format!(", store warmed for {} packages", report.store_warmed)
} else {
String::new()
};
eprintln!(
"vivacity: {} installed, {} unchanged, {} removed ({} from store, {} from cache, {} from network){warmed}{autoload_note} in {:.2}s",
report.installed,
report.unchanged,
report.removed,
report.store_hits,
report.from_cache,
report.from_network,
t0.elapsed().as_secs_f32()
);
Ok(0)
}
fn emulate_pest_plugin(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
order: &[&str],
plugins_enabled: bool,
previously_present: bool,
) -> anyhow::Result<()> {
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
let wanted: std::collections::BTreeMap<&str, &vivacity_core::lock::LockPackage> = local
.wanted_packages(with_dev)
.map(|p| (p.name(), p))
.collect();
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, vivacity_core::pest_plugin::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if !plugins_enabled || !allowed || !wanted.contains_key(vivacity_core::pest_plugin::PLUGIN_NAME)
{
if previously_present {
vivacity_core::pest_plugin::remove_pest_plugins(&vendor)?;
}
return Ok(());
}
let extras: Vec<Option<&serde_json::Value>> = order
.iter()
.filter_map(|n| wanted.get(n))
.map(|p| p.raw.get("extra"))
.collect();
vivacity_core::pest_plugin::write_pest_plugins(&vendor, &extras, manifest.get("extra"))?;
Ok(())
}
fn emulate_yii2_composer(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
order: &[&str],
touched: &[&str],
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_core::yii2_composer as yii;
let wanted: std::collections::BTreeMap<&str, &vivacity_core::lock::LockPackage> = local
.wanted_packages(with_dev)
.map(|p| (p.name(), p))
.collect();
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, yii::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if !plugins_enabled || !allowed || !wanted.contains_key(yii::PLUGIN_NAME) {
return Ok(());
}
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
yii::ensure_extensions_file(&vendor)?;
let is_extension = |n: &str| {
wanted
.get(n)
.is_some_and(|p| p.package_type() == yii::EXTENSION_TYPE)
};
let extension_touched = touched.iter().any(|n| {
is_extension(n)
|| local
.packages
.iter()
.chain(local.packages_dev.iter())
.any(|p| p.name() == *n && p.package_type() == yii::EXTENSION_TYPE)
});
if !extension_touched {
return Ok(());
}
let entries: Vec<(&str, serde_json::Value)> = order
.iter()
.filter(|n| is_extension(n))
.map(|n| (*n, yii::extension_entry(wanted[n])))
.collect();
yii::write_extensions(&vendor, &entries)?;
Ok(())
}
fn emulate_c3(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
previously_present: bool,
after_update: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_core::c3_plugin as c3;
if !plugins_enabled {
return Ok(());
}
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, c3::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
let wanted = local
.wanted_packages(with_dev)
.any(|p| p.name() == c3::PLUGIN_NAME);
if !wanted {
if previously_present && allowed && c3::delete_c3(project)? {
println!("[codeception/c3] Deleting c3.php from the root of your project...");
}
return Ok(());
}
if !allowed {
return Ok(());
}
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
match c3::copy_c3(&vendor, project)? {
c3::C3Action::UpToDate if !after_update => {
println!("[codeception/c3] c3.php is already up-to-date");
}
c3::C3Action::Copied => {
println!("[codeception/c3] Copying c3.php to the root of your project...");
println!("[codeception/c3] Include c3.php into index.php in order to collect codecoverage from server scripts");
}
_ => {}
}
Ok(())
}
fn emulate_bamarni_bin(
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
) {
use vivacity_core::bamarni_bin as bin;
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, bin::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if !plugins_enabled
|| !allowed
|| !local
.wanted_packages(with_dev)
.any(|p| p.name() == bin::PLUGIN_NAME)
{
return;
}
if let Ok(cfg) = bin::config(manifest.get("extra")) {
bin::print_deprecations(&cfg);
}
}
fn emulate_package_versions(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_core::package_versions as pv;
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, pv::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if !plugins_enabled
|| !allowed
|| !local
.wanted_packages(with_dev)
.any(|p| p.name() == pv::PLUGIN_NAME)
{
return Ok(());
}
let root = vivacity_core::state::RootPackage::detect(manifest, project, with_dev);
let replaces: Vec<(String, String)> = manifest
.get("replace")
.and_then(serde_json::Value::as_object)
.map(|m| {
m.iter()
.filter_map(|(k, v)| v.as_str().map(|c| (k.to_lowercase(), c.to_owned())))
.collect()
})
.unwrap_or_default();
let versions = pv::versions(
local,
with_dev,
&root.name,
&root.pretty_version,
root.reference.as_deref().unwrap_or(""),
&replaces,
);
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
pv::write(&vendor, &pv::render(&root.name, &versions))?;
Ok(())
}
fn download_lines(
lock: &vivacity_core::lock::Lock,
arena: &[vivacity_resolver::package::Package],
operations: &[vivacity_resolver::transaction::Operation],
with_dev: bool,
) -> Vec<String> {
use vivacity_resolver::transaction::{DisplayRef, Operation};
let by_name: std::collections::BTreeMap<&str, &vivacity_core::lock::LockPackage> = lock
.wanted_packages(with_dev)
.map(|p| (p.name(), p))
.collect();
let cache_root = vivacity_core::fetch::composer_cache_dir();
let mut lines = Vec::new();
for op in operations {
let target = match *op {
Operation::Install(p) | Operation::Update(_, p) => p,
_ => continue,
};
let package = &arena[target];
let Some(locked) = by_name.get(package.name.as_str()) else {
continue;
};
let kind = match locked
.raw
.get("dist")
.and_then(|d| d.get("type"))
.and_then(serde_json::Value::as_str)
{
Some(kind) if kind != "path" => kind.to_owned(),
_ => continue,
};
let Some(url) = locked.dist_url_expanded() else {
continue;
};
let cached =
vivacity_core::fetch::dist_cache_path_of(&cache_root, locked.name(), &url, &kind);
if cached.exists() {
continue;
}
lines.push(format!(
" - Downloading {} ({})",
package.name,
vivacity_resolver::transaction::full_pretty_version(
package,
true,
DisplayRef::SourceRefIfDev
)
));
}
lines
}
fn operation_lines(
project: &std::path::Path,
arena: &[vivacity_resolver::package::Package],
operations: &[vivacity_resolver::transaction::Operation],
layout: &vivacity_core::layout::Layout,
flex_packs: bool,
plugins_enabled: bool,
) -> anyhow::Result<Vec<String>> {
use vivacity_resolver::transaction::Operation;
let mut lines = Vec::new();
for op in operations {
let Some(shown) = op.show(arena, false) else {
continue;
};
let appendix = match *op {
Operation::Install(p) | Operation::Update(_, p) => {
let pkg = &arena[p];
match pkg.dist.as_ref() {
Some(d) if d.kind == "path" => {
let install_path = layout
.abs(&pkg.name)
.unwrap_or_else(|| layout.vendor_dir().join(&pkg.name));
match vivacity_core::path_install::install_appendix(
project,
&install_path,
&d.url,
pkg.raw.get("transport-options"),
) {
Ok(a) => a,
Err(vivacity_core::Error::Refused(msg)) => anyhow::bail!("{msg}"),
Err(e) => return Err(e.into()),
}
}
Some(_)
if pkg.package_type != "metapackage"
&& !(flex_packs && pkg.package_type == "symfony-pack") =>
{
": Extracting archive".to_owned()
}
_ => String::new(),
}
}
Operation::Uninstall(p) => {
let pkg = &arena[p];
match pkg.dist.as_ref() {
Some(d) if d.kind == "path" => {
let install_path = layout
.abs(&pkg.name)
.unwrap_or_else(|| layout.vendor_dir().join(&pkg.name));
if vivacity_core::path_install::is_own_source(
project,
&install_path.to_string_lossy(),
&d.url,
) {
format!(", source is still present in {}", install_path.display())
} else {
String::new()
}
}
_ => String::new(),
}
}
_ => String::new(),
};
lines.push(format!(" - {shown}{appendix}"));
if !plugins_enabled {
if let Operation::Install(p) | Operation::Update(_, p) = *op {
let pkg = &arena[p];
if matches!(
pkg.package_type.as_str(),
"composer-plugin" | "composer-installer"
) {
lines.push(format!(
"The \"{}\" plugin was not loaded as plugins are disabled.",
pkg.name
));
}
}
}
}
Ok(lines)
}
fn config_bool(manifest: &serde_json::Value, key: &str) -> bool {
manifest
.get("config")
.and_then(|c| c.get(key))
.and_then(serde_json::Value::as_bool)
.unwrap_or(false)
}
fn effective_optimize(manifest: &serde_json::Value, optimize: bool, authoritative: bool) -> bool {
optimize
|| authoritative
|| config_bool(manifest, "classmap-authoritative")
|| config_bool(manifest, "optimize-autoloader")
}
#[allow(clippy::too_many_arguments)]
fn dump_autoload_plan(
project: &std::path::Path,
lock: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
dev_mode: bool,
optimize: bool,
authoritative: bool,
ignore_all: bool,
ignored: &[String],
apcu: (bool, Option<&str>),
plugins_enabled: bool,
dev_package_names: Vec<String>,
) -> anyhow::Result<PlannedDump> {
let platform_check = match manifest.get("config").and_then(|c| c.get("platform-check")) {
Some(serde_json::Value::Bool(false)) => vivacity_autoload::PlatformCheckMode::Off,
Some(serde_json::Value::Bool(true)) => vivacity_autoload::PlatformCheckMode::Full,
_ => vivacity_autoload::PlatformCheckMode::PhpOnly,
};
let cfg_bool = |key: &str| config_bool(manifest, key);
let authoritative = authoritative || cfg_bool("classmap-authoritative");
let optimize = effective_optimize(manifest, optimize, authoritative);
let apcu_prefix = if apcu.1.is_some() || apcu.0 || cfg_bool("apcu-autoloader") {
Some(apcu.1.map(str::to_owned).unwrap_or_else(|| {
use std::fmt::Write as _;
let mut s = String::new();
for b in vivacity_core::random_bytes(10) {
let _ = write!(s, "{b:02x}");
}
s
}))
} else {
None
};
let opts = vivacity_autoload::DumpOptions {
apcu_prefix,
dev_mode,
optimize,
authoritative,
platform_check,
ignore_all_platform_reqs: ignore_all || ignored.iter().any(|p| p == "*"),
ignored_platform_reqs: ignored.to_vec(),
suffix: None,
dev_package_names,
classmap_cache: if std::env::var_os("VIVACITY_NO_CLASSMAP_CACHE").is_some() {
None
} else {
Some(vivacity_autoload::ClassmapCacheConfig {
store_root: vivacity_core::platform::cache_dir().join("store"),
cache_root: vivacity_core::platform::cache_dir(),
})
},
};
let (plan, report) = vivacity_autoload::plan(project, lock, manifest, layout, &opts)?;
Ok(PlannedDump {
plan,
report,
runtime_stub: plugins_enabled
&& lock
.wanted_packages(dev_mode)
.any(|p| p.name() == "symfony/runtime")
&& matches!(
vivacity_core::layout::plugin_allowed(manifest, "symfony/runtime"),
vivacity_core::layout::PluginVerdict::Allowed
),
})
}
struct PlannedDump {
plan: vivacity_autoload::DumpPlan,
report: vivacity_autoload::DumpReport,
runtime_stub: bool,
}
impl PlannedDump {
fn finish(
self,
project: &std::path::Path,
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
) -> anyhow::Result<vivacity_autoload::DumpReport> {
self.plan.commit()?;
if self.runtime_stub {
vivacity_core::runtime_stub::write_stub(&layout.vendor_dir(), project, manifest)?;
}
for w in &self.report.warnings {
eprintln!("{w}");
}
Ok(self.report)
}
}
#[allow(clippy::too_many_arguments)]
fn dump_autoload(
project: &std::path::Path,
lock: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
dev_mode: bool,
optimize: bool,
authoritative: bool,
ignore_all: bool,
ignored: &[String],
apcu: (bool, Option<&str>),
plugins_enabled: bool,
dev_package_names: Vec<String>,
) -> anyhow::Result<vivacity_autoload::DumpReport> {
dump_autoload_plan(
project,
lock,
manifest,
layout,
dev_mode,
optimize,
authoritative,
ignore_all,
ignored,
apcu,
plugins_enabled,
dev_package_names,
)?
.finish(project, manifest, layout)
}
fn merge_plugin_root(
project: &std::path::Path,
lock: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
) -> Result<Option<vivacity_resolver::merge_plugin::Merged>, String> {
use vivacity_resolver::merge_plugin;
let present = lock
.wanted_packages(with_dev)
.any(|p| p.name() == merge_plugin::PLUGIN_NAME)
|| installed_packages(project, manifest)
.iter()
.any(|p| p.get("name").and_then(|n| n.as_str()) == Some(merge_plugin::PLUGIN_NAME));
merge_root_when(project, manifest, with_dev, plugins_enabled && present)
}
fn merge_root_when(
project: &std::path::Path,
manifest: &serde_json::Value,
with_dev: bool,
present: bool,
) -> Result<Option<vivacity_resolver::merge_plugin::Merged>, String> {
use vivacity_resolver::merge_plugin::{self, Settings};
if !present
|| !matches!(
vivacity_core::layout::plugin_allowed(manifest, merge_plugin::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
)
|| !Settings::declared(manifest)
{
return Ok(None);
}
let root = vivacity_core::state::RootPackage::detect(manifest, project, with_dev);
let mut merged = merge_plugin::merge(
project,
manifest,
&root.version,
&root.pretty_version,
with_dev,
)?;
let original_alias = manifest
.get("extra")
.and_then(|e| e.get("branch-alias"))
.cloned();
if let Some(extra) = merged
.manifest
.get_mut("extra")
.and_then(|e| e.as_object_mut())
{
match original_alias {
Some(a) => {
extra.insert("branch-alias".to_owned(), a);
}
None => {
extra.remove("branch-alias");
}
}
}
Ok(Some(merged))
}
fn refuse_merge_plugin_resolution(
project: &std::path::Path,
manifest: &serde_json::Value,
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_resolver::merge_plugin::{self, Settings};
let required = ["require", "require-dev"].iter().any(|k| {
manifest
.get(k)
.and_then(|m| m.get(merge_plugin::PLUGIN_NAME))
.is_some()
});
let installed = vivacity_core::scope::active_plugins(project, manifest, plugins_enabled)
.iter()
.any(|p| p == merge_plugin::PLUGIN_NAME);
if plugins_enabled
&& required
&& !installed
&& matches!(
vivacity_core::layout::plugin_allowed(manifest, merge_plugin::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
)
&& Settings::declared(manifest)
{
anyhow::bail!(
"wikimedia/composer-merge-plugin is not installed yet: Composer would resolve without the merge, then run the plugin's implicit update once it is installed (not emulated) — run `composer update` for this project"
);
}
Ok(())
}
fn composer_dir_of(project: &std::path::Path, manifest: &serde_json::Value) -> std::path::PathBuf {
vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.composer_dir(project)
}
fn run_dump(args: &DumpArgs) -> anyhow::Result<i32> {
let t0 = std::time::Instant::now();
let project = project_dir(args.working_dir.as_deref())?;
refuse_alternate_manifest()?;
let manifest: serde_json::Value = serde_json::from_str(
&std::fs::read_to_string(project.join("composer.json"))
.context("cannot read composer.json")?,
)
.context("invalid composer.json")?;
if let Some(code) = refuse_invalid_root(&manifest) {
return Ok(code);
}
let lock = vivacity_core::lock::Lock::read(&project.join("composer.lock"))?;
if vivacity_core::scope::active_plugins(&project, &manifest, !args.no_plugins)
.iter()
.any(|p| p == vivacity_core::bamarni_bin::PLUGIN_NAME)
{
if let Ok(cfg) = vivacity_core::bamarni_bin::config(manifest.get("extra")) {
vivacity_core::bamarni_bin::print_deprecations(&cfg);
}
}
let installed_json =
vivacity_core::jsonfile::read(&composer_dir_of(&project, &manifest).join("installed.json"));
let installed_dev = installed_json
.as_ref()
.and_then(|v| v.get("dev").and_then(serde_json::Value::as_bool))
.unwrap_or(true);
let installed_dev_package_names: Vec<String> = installed_json
.as_ref()
.and_then(|v| {
v.get("dev-package-names")
.and_then(serde_json::Value::as_array)
})
.map(|a| {
a.iter()
.filter_map(|n| n.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default();
let dev_mode = !args.no_dev && installed_dev;
let manifest = match merge_plugin_root(&project, &lock, &manifest, dev_mode, !args.no_plugins) {
Ok(Some(m)) => m.manifest,
Ok(None) => manifest,
Err(reason) => {
eprintln!("vivacity: this lock is outside what vivacity handles natively:");
eprintln!(" - wikimedia/composer-merge-plugin: {reason}");
eprintln!("Run `composer dump-autoload` instead.");
return Ok(3);
}
};
let layout = match vivacity_core::layout::Layout::resolve(
&project,
&lock,
&manifest,
dev_mode,
!args.no_plugins,
) {
Ok(l) => l,
Err(issues) => {
eprintln!("vivacity: this lock is outside what vivacity handles natively:");
for i in &issues {
eprintln!(" - {i}");
}
eprintln!("Run `composer dump-autoload` instead.");
return Ok(3);
}
};
if !args.no_plugins {
let issues = vivacity_core::scope::plugin_issues(&lock, installed_dev);
if !issues.is_empty() {
eprintln!("vivacity: this lock is outside what vivacity handles natively:");
for i in &issues {
eprintln!(" - {i}");
}
eprintln!("Run `composer dump-autoload` instead.");
return Ok(3);
}
}
let installed_order: Vec<String> = installed_packages(&project, &manifest)
.iter()
.filter_map(|p| {
p.get("name")
.and_then(serde_json::Value::as_str)
.map(str::to_owned)
})
.collect();
let runner = if args.run_scripts {
match scripts::Runner::new(&project, &manifest, dev_mode, which_composer()) {
Ok(r) => r,
Err(e) => {
eprintln!("vivacity: {e}");
return Ok(3);
}
}
} else {
None
};
if let Some(r) = &runner {
let code = r.run(scripts::PRE_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(code);
}
}
let report = dump_autoload(
&project,
&lock,
&manifest,
&layout,
dev_mode,
args.optimize || args.classmap_authoritative,
args.classmap_authoritative,
args.ignore_platform_reqs,
&args.ignore_platform_req,
(args.apcu_autoloader, args.apcu_autoloader_prefix.as_deref()),
!args.no_plugins,
installed_dev_package_names,
)?;
{
let order: Vec<&str> = installed_order.iter().map(String::as_str).collect();
let previously_present = order.contains(&vivacity_core::pest_plugin::PLUGIN_NAME);
emulate_pest_plugin(
&project,
&lock,
&manifest,
dev_mode,
&order,
!args.no_plugins,
previously_present,
)?;
emulate_yii2_composer(
&project,
&lock,
&manifest,
dev_mode,
&order,
&[],
!args.no_plugins,
)?;
emulate_bamarni_bin(&lock, &manifest, dev_mode, !args.no_plugins);
emulate_package_versions(&project, &lock, &manifest, dev_mode, !args.no_plugins)?;
}
if let Some(r) = &runner {
let code = r.run(scripts::POST_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(code);
}
}
eprintln!(
"vivacity: autoloader generated ({} classes) in {:.2}s",
report.classes,
t0.elapsed().as_secs_f32()
);
Ok(0)
}
fn fallback_or_fail(
args: &InstallArgs,
project: &std::path::Path,
scope: &vivacity_core::scope::ScopeReport,
) -> anyhow::Result<i32> {
eprintln!("vivacity: this lock is outside what vivacity handles natively:");
for issue in &scope.issues {
eprintln!(" - {issue}");
}
if args.no_fallback || args.check_scope {
eprintln!("--no-fallback given: stopping here (no partial vendor/ was written).");
return Ok(3);
}
let composer = which_composer();
let Some(composer) = composer else {
eprintln!(
"composer not found for the fallback — install Composer or remove the unsupported items."
);
return Ok(3);
};
eprintln!("vivacity: delegating to `composer install`…");
let mut cmd = std::process::Command::new(composer);
cmd.arg("install").current_dir(project);
if !args.run_scripts || args.no_scripts {
cmd.arg("--no-scripts");
}
if args.no_plugins {
cmd.arg("--no-plugins");
}
if args.no_dev {
cmd.arg("--no-dev");
}
if args.no_autoloader {
cmd.arg("--no-autoloader");
}
if args.optimize_autoloader {
cmd.arg("--optimize-autoloader");
}
if args.classmap_authoritative {
cmd.arg("--classmap-authoritative");
}
if args.ignore_platform_reqs {
cmd.arg("--ignore-platform-reqs");
}
for req in &args.ignore_platform_req {
cmd.arg(format!("--ignore-platform-req={req}"));
}
#[cfg(unix)]
if !args.spawn_fallback {
use std::os::unix::process::CommandExt as _;
let err = cmd.exec();
return Err(err).context("cannot exec composer");
}
let status = cmd.status().context("cannot run composer")?;
Ok(status.code().unwrap_or(1))
}
fn which_composer() -> Option<PathBuf> {
let path = std::env::var_os("PATH")?;
let names: &[&str] = if cfg!(windows) {
&["composer.bat", "composer.cmd", "composer.exe", "composer"]
} else {
&["composer"]
};
std::env::split_paths(&path)
.flat_map(|d| names.iter().map(move |n| d.join(n)))
.find(|c| c.is_file())
}
enum PlatformOutcome {
Failures(Vec<vivacity_core::platform::PlatformFailure>),
NoPhp { warn: bool },
}
fn http_transport(
project: &std::path::Path,
offline: bool,
) -> anyhow::Result<vivacity_resolver::repository::HttpTransports> {
let runtime =
Arc::new(tokio::runtime::Runtime::new().context("cannot start the async runtime")?);
let fetcher = Arc::new(vivacity_core::fetch::Fetcher::new(
vivacity_core::fetch::composer_cache_dir(),
vivacity_core::fetch::Auth::load(project),
)?);
fn to_fetched(
r: vivacity_core::fetch::MetadataResponse,
) -> vivacity_resolver::repository::Fetched {
use vivacity_core::fetch::MetadataResponse as M;
use vivacity_resolver::repository::Fetched as F;
match r {
M::NotModified => F::NotModified,
M::NotFound => F::NotFound,
M::Body {
bytes,
last_modified,
} => F::Body {
bytes,
last_modified,
},
}
}
let http: vivacity_resolver::repository::HttpFetch = {
let runtime = runtime.clone();
let fetcher = fetcher.clone();
Arc::new(move |url: &str, ims: Option<&str>| {
if offline {
return Err(format!("offline: cannot fetch {url}"));
}
runtime
.block_on(fetcher.metadata_fetch(url, ims))
.map(to_fetched)
.map_err(|e| e.to_string())
})
};
let http_many: vivacity_resolver::repository::HttpFetchMany = {
let runtime = runtime.clone();
let fetcher = fetcher.clone();
Arc::new(move |requests: &[vivacity_resolver::repository::Request]| {
if offline {
return requests
.iter()
.map(|(u, _)| Err(format!("offline: cannot fetch {u}")))
.collect();
}
let requests: Vec<(String, Option<String>)> = requests.to_vec();
runtime.block_on(async {
let sem = Arc::new(tokio::sync::Semaphore::new(12));
let tasks: Vec<_> = requests
.into_iter()
.map(|(u, ims)| {
let sem = sem.clone();
let fetcher = fetcher.clone();
async move {
let _permit = sem.acquire().await;
fetcher
.metadata_fetch(&u, ims.as_deref())
.await
.map(to_fetched)
.map_err(|e| e.to_string())
}
})
.collect();
futures_join_all(tasks).await
})
})
};
let http_post: vivacity_resolver::repository::HttpPost = {
let runtime = runtime.clone();
let fetcher = fetcher.clone();
Arc::new(move |url: &str, body: &str| {
if offline {
return Err(format!("offline: cannot fetch {url}"));
}
runtime
.block_on(fetcher.post_form(url, body))
.map(to_fetched)
.map_err(|e| e.to_string())
})
};
Ok((http, Some(http_many), Some(http_post)))
}
fn package_of_requirement(entry: &str) -> &str {
match entry.find([' ', '=', ':']) {
Some(i)
if entry[i + 1..]
.trim_start_matches([' ', '=', ':'])
.is_empty() =>
{
entry
}
Some(i) => &entry[..i],
None => entry,
}
}
fn temporary_requirements(
with: &[String],
packages: &[String],
) -> anyhow::Result<Vec<(String, String)>> {
let mut out: Vec<(String, String)> = Vec::new();
let carrying: Vec<String> = packages
.iter()
.filter(|p| package_of_requirement(p) != p.as_str())
.cloned()
.collect();
for source in [with, &carrying] {
for (name, version) in vivacity_resolver::version::parse_name_version_pairs(source) {
let Some(version) = version else {
anyhow::bail!(
"Option {name} is missing a version constraint, use e.g. {name}:^1.0"
);
};
match out.iter_mut().find(|(n, _)| *n == name) {
Some(slot) => slot.1 = version,
None => out.push((name, version)),
}
}
}
Ok(out)
}
fn run_update(args: &UpdateArgs) -> anyhow::Result<i32> {
let env_flag = |name: &str| std::env::var(name).is_ok_and(|v| !v.is_empty() && v != "0");
for p in &args.packages {
if ["lock", "nothing", "mirrors"].contains(&p.as_str()) {
anyhow::bail!(
"`vivacity update {p}` (lock file metadata refresh) is not supported yet"
);
}
}
let transitive = if args.with_all_dependencies || env_flag("COMPOSER_WITH_ALL_DEPENDENCIES") {
vivacity_resolver::pool::UpdateMode::ListedWithTransitiveDeps
} else if args.with_dependencies || env_flag("COMPOSER_WITH_DEPENDENCIES") {
vivacity_resolver::pool::UpdateMode::ListedWithTransitiveDepsNoRootRequire
} else {
vivacity_resolver::pool::UpdateMode::OnlyListed
};
let reqs = temporary_requirements(&args.with, &args.packages)?;
let allow_list: Vec<String> = args
.packages
.iter()
.map(|p| package_of_requirement(p).to_owned())
.collect();
let mut options = if allow_list.is_empty() {
vivacity_resolver::session::UpdateOptions::default()
} else {
vivacity_resolver::session::UpdateOptions::partial(&allow_list, transitive)
};
options.no_blocking = args.no_blocking || args.no_security_blocking;
options.temporary_requirements = reqs;
let prefer_stable = args.prefer_stable || env_flag("COMPOSER_PREFER_STABLE");
let prefer_lowest = args.prefer_lowest || env_flag("COMPOSER_PREFER_LOWEST");
{
let project = project_dir(args.working_dir.as_deref())?;
if let Ok(manifest) = std::fs::read_to_string(project.join("composer.json"))
.map_err(anyhow::Error::from)
.and_then(|t| serde_json::from_str::<serde_json::Value>(&t).map_err(Into::into))
{
if let Some(code) = resolution_fallback(
&project,
&manifest,
vivacity_core::scope::ResolutionCommand::Update,
args.no_plugins,
args.no_fallback,
!args.no_install && !args.dry_run,
)? {
return Ok(code);
}
}
}
run_update_resolved(args, options, prefer_stable, prefer_lowest)
}
fn run_update_resolved(
args: &UpdateArgs,
options: vivacity_resolver::session::UpdateOptions,
prefer_stable: bool,
prefer_lowest: bool,
) -> anyhow::Result<i32> {
let resolved = resolve_and_lock(args, options, prefer_stable, prefer_lowest)?;
if resolved.status != 0 {
return Ok(resolved.status);
}
let project = project_dir(args.working_dir.as_deref())?;
if !args.no_install {
let (virtual_lock, virtual_manifest) = if args.dry_run {
(resolved.lock.clone(), Some(resolved.manifest.clone()))
} else {
(None, None)
};
let status = install_after_update(args, virtual_lock, virtual_manifest)?;
if status != 0 {
return Ok(status);
}
}
print_post_update(&resolved, &project);
Ok(0)
}
fn install_after_update(
args: &UpdateArgs,
virtual_lock: Option<serde_json::Value>,
virtual_manifest: Option<serde_json::Value>,
) -> anyhow::Result<i32> {
run_install(&InstallArgs {
prefer_source: false,
prefer_dist: false,
prefer_install: None,
no_progress: args.no_progress,
no_dev: args.no_dev,
no_autoloader: args.no_autoloader,
optimize_autoloader: args.optimize_autoloader,
classmap_authoritative: args.classmap_authoritative,
apcu_autoloader: args.apcu_autoloader,
apcu_autoloader_prefix: args.apcu_autoloader_prefix.clone(),
no_scripts: args.no_scripts,
run_scripts: false,
no_plugins: args.no_plugins,
ignore_platform_reqs: args.ignore_platform_reqs,
ignore_platform_req: args.ignore_platform_req.clone(),
no_fallback: args.no_fallback,
check_scope: false,
offline: args.offline,
no_blocking: args.no_blocking,
no_security_blocking: args.no_security_blocking,
no_install: false,
dry_run: args.dry_run,
working_dir: args.working_dir.clone(),
spawn_fallback: args.spawn_fallback,
after_update: true,
virtual_lock,
virtual_manifest,
})
}
pub(crate) struct Resolved {
pub(crate) status: i32,
pub(crate) lock: Option<serde_json::Value>,
pub(crate) post: Vec<String>,
pub(crate) manifest: serde_json::Value,
pub(crate) flex_active: bool,
pub(crate) thanks_reminder: bool,
}
pub(crate) fn print_post_update(resolved: &Resolved, project: &std::path::Path) {
for line in &resolved.post {
eprintln!("{line}");
}
print_funding(project, &resolved.manifest);
if resolved.flex_active {
print_flex_post_update(&resolved.manifest, resolved.thanks_reminder);
}
}
fn refuse_alternate_manifest() -> anyhow::Result<()> {
if let Some(f) = std::env::var("COMPOSER").ok().map(|f| f.trim().to_owned()) {
if !f.is_empty() && f != "composer.json" && f != "./composer.json" {
anyhow::bail!("COMPOSER={f}: an alternate manifest is not supported yet");
}
}
Ok(())
}
fn refuse_invalid_root(manifest: &serde_json::Value) -> Option<i32> {
let err = vivacity_resolver::root::manifest_error(manifest)?;
eprintln!("{err}");
Some(1)
}
fn flex_synchronize_enabled(manifest: &serde_json::Value) -> bool {
match manifest
.get("extra")
.and_then(|e| e.get("symfony/flex"))
.and_then(|f| f.get("synchronize_package_json"))
{
None => true,
Some(v) => php_truthy(v),
}
}
fn php_truthy(v: &serde_json::Value) -> bool {
match v {
serde_json::Value::Null => false,
serde_json::Value::Bool(b) => *b,
serde_json::Value::Number(n) => n.as_f64().is_some_and(|f| f != 0.0),
serde_json::Value::String(s) => !s.is_empty() && s != "0",
serde_json::Value::Array(a) => !a.is_empty(),
serde_json::Value::Object(o) => !o.is_empty(),
}
}
fn print_flex_post_update(manifest: &serde_json::Value, thanks_reminder: bool) {
let sync = flex_synchronize_enabled(manifest);
let enabled = flex_downloader_enabled(manifest);
if !enabled {
eprintln!(
"Symfony recipes are disabled: \"symfony/flex\" not found in the root composer.json"
);
}
if thanks_reminder {
let (love, star) = if cfg!(windows) {
("love", "star")
} else {
("\u{1f496} ", "\u{2605} ")
};
eprintln!();
eprintln!(
"What about running composer global require symfony/thanks && composer thanks now?"
);
eprintln!(
"This will spread some {love} by sending a {star} to the GitHub repositories of your fellow package maintainers."
);
}
eprintln!();
if !sync {
eprintln!("Skip synchronizing package.json with PHP packages");
} else if !enabled {
eprintln!("Synchronizing package.json is disabled: \"symfony/flex\" not found in the root composer.json");
}
if enabled {
eprintln!("Run composer recipes at any time to see the status of your Symfony recipes.");
eprintln!();
}
}
fn flex_root_dir(project: &std::path::Path, manifest: &serde_json::Value) -> std::path::PathBuf {
let extra = manifest.get("extra");
extra
.and_then(|e| e.get("root-dir"))
.or_else(|| {
extra
.and_then(|e| e.get("symfony"))
.and_then(|s| s.get("root-dir"))
})
.and_then(serde_json::Value::as_str)
.map(|d| project.join(d))
.unwrap_or_else(|| project.to_path_buf())
}
fn flex_dotenv_paths(
project: &std::path::Path,
manifest: &serde_json::Value,
) -> (std::path::PathBuf, std::path::PathBuf) {
let root_dir = flex_root_dir(project, manifest);
let dotenv = manifest
.get("extra")
.and_then(|e| e.get("runtime"))
.and_then(|r| r.get("dotenv_path"))
.and_then(serde_json::Value::as_str)
.map(|p| root_dir.join(p))
.unwrap_or_else(|| root_dir.join(".env"));
let dist = std::path::PathBuf::from(format!("{}.dist", dotenv.to_string_lossy()));
(dotenv, dist)
}
fn flex_downloader_enabled(manifest: &serde_json::Value) -> bool {
["require", "require-dev"].iter().any(|k| {
manifest
.get(k)
.and_then(|m| m.get("symfony/flex"))
.is_some()
})
}
fn flex_reinstall_reason(
project: &std::path::Path,
manifest: &serde_json::Value,
lock_value: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
) -> Option<String> {
if !plugins_enabled
|| vivacity_core::layout::plugin_allowed(manifest, "symfony/flex")
!= vivacity_core::layout::PluginVerdict::Allowed
{
return None;
}
let installed = installed_packages(project, manifest);
if installed
.iter()
.any(|i| i.get("name").and_then(serde_json::Value::as_str) == Some("symfony/flex"))
{
return None;
}
vivacity_core::lock::Lock::from_value(lock_value)
.wanted_packages(with_dev)
.any(|p| p.name() == "symfony/flex")
.then(|| {
"would install itself, then run a second install of its own with its pool filter active (not emulated)"
.to_owned()
})
}
fn flex_install_reason(
project: &std::path::Path,
manifest: &serde_json::Value,
lock_value: &serde_json::Value,
with_dev: bool,
offline: bool,
plugins_enabled: bool,
) -> anyhow::Result<Option<String>> {
let lock = vivacity_core::lock::Lock::from_value(lock_value);
let installed = installed_packages(project, manifest);
let locked = flex::lock_names(project);
let wanted: std::collections::BTreeSet<&str> =
lock.wanted_packages(with_dev).map(|p| p.name()).collect();
let dev_names: std::collections::BTreeSet<&str> = lock_value
.get("packages-dev")
.and_then(serde_json::Value::as_array)
.map(|a| {
a.iter()
.filter_map(|p| p.get("name").and_then(serde_json::Value::as_str))
.collect()
})
.unwrap_or_default();
for entry in &installed {
let Some(name) = entry.get("name").and_then(serde_json::Value::as_str) else {
continue;
};
if wanted.contains(name) || !locked.contains(name) {
continue;
}
if !with_dev && dev_names.contains(name) {
continue;
}
return Ok(Some(format!(
"would unconfigure {name} and drop it from symfony.lock (not emulated)"
)));
}
let recorded: Vec<&vivacity_core::lock::LockPackage> = lock
.wanted_packages(with_dev)
.filter(|p| !locked.contains(p.name()))
.collect();
if recorded.is_empty() {
return Ok(None);
}
let index = flex::recipe_index(project, manifest, offline)?;
for p in &recorded {
if index.applies_to(p.name(), p.version(), p.raw.get("extra")) {
return Ok(Some(format!(
"would apply the recipe of {} (not emulated)",
p.name()
)));
}
}
let dirs = vivacity_core::dirs::Dirs::resolve(manifest).unwrap_or_default();
let vendor = dirs.vendor_dir(project);
let vendor_rel = dirs.vendor_rel().to_owned();
let layout =
vivacity_core::layout::Layout::resolve(project, &lock, manifest, with_dev, plugins_enabled)
.ok();
enum Where {
Elsewhere,
LaidOut,
Dist,
}
let placed: Vec<(&vivacity_core::lock::LockPackage, Where)> = recorded
.iter()
.map(|p| {
let at_vendor = layout.as_ref().is_none_or(|l| {
l.rel(p.name())
.is_none_or(|rel| rel == format!("{vendor_rel}/{}", p.name()))
});
let has_candidate =
!flex::bundle_candidate_paths(&serde_json::Value::Object(p.raw.clone())).is_empty();
let w = if !at_vendor || !has_candidate {
Where::Elsewhere
} else if installed_as_locked(&installed, p) {
Where::LaidOut
} else {
Where::Dist
};
(*p, w)
})
.collect();
let reader = if placed.iter().any(|(_, w)| matches!(w, Where::Dist)) {
Some(flex::DistReader::new(project)?)
} else {
None
};
for (p, w) in &placed {
let raw = serde_json::Value::Object(p.raw.clone());
let answer = match w {
Where::Elsewhere => flex::has_bundle_class_from(&raw, &flex::ClassSource::Elsewhere),
Where::LaidOut => {
let root = vendor.join(p.name());
flex::has_bundle_class_from(&raw, &flex::ClassSource::LaidOut(&root))
}
Where::Dist => {
let Some(reader) = reader.as_ref() else {
return Ok(Some(format!(
"cannot read {}'s dist before writing (no reader)",
p.name()
)));
};
match reader.dist_bytes(p, offline) {
Ok((bytes, kind)) => flex::has_bundle_class_from(
&raw,
&flex::ClassSource::Dist {
bytes: &bytes,
kind,
},
),
Err(e) => {
return Ok(Some(format!(
"cannot tell whether {} registers a bundle before writing ({e})",
p.name()
)))
}
}
}
};
match answer {
Ok(true) => {
return Ok(Some(format!(
"would register {}'s bundle in config/bundles.php (not emulated)",
p.name()
)))
}
Ok(false) => {}
Err(e) => {
return Ok(Some(format!(
"cannot tell whether {} registers a bundle before writing ({e})",
p.name()
)))
}
}
}
Ok(None)
}
fn installed_as_locked(
installed: &[serde_json::Value],
p: &vivacity_core::lock::LockPackage,
) -> bool {
let wanted = serde_json::Value::Object(p.raw.clone());
installed.iter().any(|i| {
i.get("name").and_then(serde_json::Value::as_str) == Some(p.name())
&& package_identity(i) == package_identity(&wanted)
})
}
fn package_identity(
p: &serde_json::Value,
) -> (
Option<serde_json::Value>,
Option<serde_json::Value>,
Option<serde_json::Value>,
Option<serde_json::Value>,
) {
let field = |a: &str, b: &str| p.get(a).and_then(|v| v.get(b)).cloned();
(
p.get("version").cloned(),
field("dist", "reference"),
field("source", "reference"),
p.get("abandoned").cloned(),
)
}
fn flex_sync_reason(
project: &std::path::Path,
manifest: &serde_json::Value,
lock_value: &serde_json::Value,
) -> Option<String> {
if !flex_synchronize_enabled(manifest) || !flex_downloader_enabled(manifest) {
return None;
}
let root_dir = flex_root_dir(project, manifest);
let importmap = root_dir.join("importmap.php");
let package_json = root_dir.join("package.json");
if !importmap.exists() && !package_json.exists() {
return None;
}
let ux = flex_ux_package(lock_value);
let controllers = root_dir.join("assets").join("controllers.json").exists();
if importmap.exists() {
if let Some(name) = ux {
return Some(format!(
"would add the symfony-ux assets of {name} to importmap.php (not emulated)"
));
}
if controllers {
return Some("would update assets/controllers.json (not emulated)".to_owned());
}
return None;
}
let text = match std::fs::read_to_string(&package_json) {
Ok(t) => t,
Err(e) => {
return Some(format!(
"would rewrite {}, which is unreadable here ({e})",
package_json.display()
))
}
};
let json: serde_json::Value = match serde_json::from_str(&text) {
Ok(v) => v,
Err(_) => return None,
};
let Some(object) = json.as_object() else {
return Some("would fail on a package.json that is not an object".to_owned());
};
if let Some(name) = ux {
return Some(format!(
"would add the JavaScript dependencies of {name} to package.json (not emulated)"
));
}
if controllers {
return Some("would update assets/controllers.json (not emulated)".to_owned());
}
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
let vendor_rel = match vendor.strip_prefix(&root_dir) {
Ok(rel) => rel.to_string_lossy().replace('\\', "/"),
Err(_) => vivacity_core::pathutil::find_shortest_path(
&root_dir.to_string_lossy(),
&vendor.to_string_lossy(),
true,
),
};
let prefix = format!("file:{}/", vendor_rel.trim_end_matches('/'));
for key in ["dependencies", "devDependencies"] {
for (name, value) in object
.get(key)
.and_then(serde_json::Value::as_object)
.into_iter()
.flatten()
{
let Some(target) = value.as_str() else {
continue;
};
if !name.starts_with('@') || !target.starts_with(&prefix) || !target.contains("/assets")
{
continue;
}
if !root_dir.join(&target[5..]).join("package.json").exists() {
return Some(format!(
"would remove the obsolete package.json link {name} (not emulated)"
));
}
}
}
let Ok(manipulator) = vivacity_resolver::json_manipulator::JsonManipulator::new(&text) else {
return Some("would fail on a package.json that is not an object".to_owned());
};
if manipulator.contents() != text {
return Some(
"would rewrite package.json, which Composer's JsonManipulator does not hand back byte for byte"
.to_owned(),
);
}
None
}
fn flex_ux_package(lock_value: &serde_json::Value) -> Option<&str> {
["packages", "packages-dev"]
.iter()
.filter_map(|k| lock_value.get(k))
.filter_map(serde_json::Value::as_array)
.flatten()
.find(|p| {
p.get("keywords")
.and_then(serde_json::Value::as_array)
.is_some_and(|k| k.iter().any(|w| w.as_str() == Some("symfony-ux")))
})
.and_then(|p| p.get("name"))
.and_then(serde_json::Value::as_str)
}
fn emulate_flex_install(
project: &std::path::Path,
manifest: &serde_json::Value,
plugins_enabled: bool,
) -> anyhow::Result<()> {
if !plugins_enabled
|| !vivacity_core::scope::active_plugins(project, manifest, plugins_enabled)
.iter()
.any(|p| p == "symfony/flex")
{
return Ok(());
}
let (dotenv, dist) = flex_dotenv_paths(project, manifest);
let local = std::path::PathBuf::from(format!("{}.local", dotenv.to_string_lossy()));
if !dotenv.exists() && !local.exists() && dist.is_file() {
let content = std::fs::read_to_string(&dist).unwrap_or_default();
if !content.contains(".env.local") {
std::fs::copy(&dist, &dotenv).with_context(|| {
format!("cannot copy {} to {}", dist.display(), dotenv.display())
})?;
}
}
eprintln!();
if flex_downloader_enabled(manifest) {
eprintln!("Run composer recipes at any time to see the status of your Symfony recipes.");
eprintln!();
}
Ok(())
}
fn flex_write_guard(project: &std::path::Path, manifest: &serde_json::Value) -> Option<String> {
let root_dir = flex_root_dir(project, manifest);
let dotenv = manifest
.get("extra")
.and_then(|e| e.get("runtime"))
.and_then(|r| r.get("dotenv_path"))
.and_then(serde_json::Value::as_str)
.map(|p| root_dir.join(p))
.unwrap_or_else(|| root_dir.join(".env"));
let dist = dotenv.with_file_name(format!(
"{}.dist",
dotenv
.file_name()
.map(|f| f.to_string_lossy().into_owned())
.unwrap_or_default()
));
let local = dotenv.with_file_name(format!(
"{}.local",
dotenv
.file_name()
.map(|f| f.to_string_lossy().into_owned())
.unwrap_or_default()
));
if !dotenv.exists() && !local.exists() && dist.exists() {
let mentions_local = std::fs::read_to_string(&dist)
.map(|t| t.contains(".env.local"))
.unwrap_or(false);
if !mentions_local {
return Some(format!(
"would copy {} to {} (not emulated)",
dist.display(),
dotenv.display()
));
}
}
let current_lock = vivacity_core::jsonfile::read(&project.join("composer.lock"))
.map(|v| (*v).clone())
.unwrap_or(serde_json::Value::Null);
if let Some(reason) = flex_sync_reason(project, manifest, ¤t_lock) {
return Some(reason);
}
if manifest.get("flex-require").is_some() || manifest.get("flex-require-dev").is_some() {
return Some(
"would merge flex-require into composer.json and run a second install of its own (not emulated)"
.to_owned(),
);
}
{
let installed = installed_packages(project, manifest);
let lock: Option<serde_json::Value> =
std::fs::read_to_string(project.join("composer.lock"))
.ok()
.and_then(|t| serde_json::from_str(&t).ok());
let by_name = |name: &str| -> Option<serde_json::Value> {
let named = |p: &serde_json::Value| {
p.get("name").and_then(serde_json::Value::as_str) == Some(name)
};
installed.iter().find(|p| named(p)).cloned().or_else(|| {
lock.as_ref().and_then(|l| {
["packages", "packages-dev"].iter().find_map(|k| {
l.get(k)
.and_then(serde_json::Value::as_array)
.and_then(|a| a.iter().find(|p| named(p)))
.cloned()
})
})
})
};
for key in ["require", "require-dev"] {
let Some(reqs) = manifest.get(key).and_then(serde_json::Value::as_object) else {
continue;
};
for name in reqs.keys() {
let lname = name.to_ascii_lowercase();
if vivacity_resolver::platform::is_platform_package(&lname) {
continue;
}
match by_name(&lname) {
Some(p) => {
let is_pack = p.get("type").and_then(serde_json::Value::as_str)
== Some("symfony-pack");
let has_links = ["require", "require-dev"].iter().any(|k| {
p.get(k)
.and_then(serde_json::Value::as_object)
.is_some_and(|m| !m.is_empty())
});
if is_pack && has_links {
return Some(format!(
"would unpack the symfony-pack {lname} into composer.json (not emulated)"
));
}
}
None => {
return Some(format!(
"looks up the root requirement {lname} (not installed nor locked) to decide an unpack (not emulated)"
));
}
}
}
}
}
None
}
fn unchanged_local_repository(
installed: &[serde_json::Value],
lock: &serde_json::Value,
with_dev: bool,
) -> Option<Vec<String>> {
use serde_json::Value;
if lock
.get("aliases")
.and_then(Value::as_array)
.is_some_and(|a| !a.is_empty())
{
return None;
}
let wanted: Vec<&Value> = ["packages", "packages-dev"]
.iter()
.take(if with_dev { 2 } else { 1 })
.filter_map(|k| lock.get(*k))
.filter_map(Value::as_array)
.flatten()
.collect();
if with_dev && lock.get("packages-dev").is_none() {
return None; }
if wanted.len() != installed.len() {
return None;
}
let aliased = |p: &Value| {
let dev = p
.get("version")
.and_then(Value::as_str)
.is_some_and(|v| v.starts_with("dev-") || v.ends_with("-dev"));
(dev && p
.get("extra")
.and_then(|e| e.get("branch-alias"))
.is_some_and(|b| !b.is_null()))
|| p.get("default-branch") == Some(&Value::Bool(true))
};
let key = |p: &Value| -> Option<String> {
p.get("name")
.and_then(Value::as_str)
.map(str::to_ascii_lowercase)
};
let identity = package_identity;
let mut by_name: std::collections::BTreeMap<String, &Value> = Default::default();
for p in &wanted {
if aliased(p) {
return None;
}
by_name.insert(key(p)?, p);
}
let mut names = Vec::with_capacity(installed.len());
for p in installed {
if aliased(p) {
return None;
}
let name = key(p)?;
if identity(by_name.get(&name)?) != identity(p) {
return None;
}
names.push(name);
}
(names.len() == by_name.len()).then_some(names)
}
fn installed_packages(
project: &std::path::Path,
manifest: &serde_json::Value,
) -> Vec<serde_json::Value> {
let composer_dir = composer_dir_of(project, manifest);
let Some(installed) = vivacity_core::jsonfile::read(&composer_dir.join("installed.json"))
else {
return Vec::new();
};
let list = installed
.get("packages")
.and_then(|p| p.as_array())
.cloned()
.or_else(|| installed.as_array().cloned())
.unwrap_or_default();
list.into_iter()
.filter(|p| {
if p.get("type").and_then(|t| t.as_str()) == Some("metapackage") {
return true;
}
match p.get("install-path").and_then(|v| v.as_str()) {
Some(rel) => composer_dir.join(rel).exists(),
None => true,
}
})
.collect()
}
fn print_funding(project: &std::path::Path, manifest: &serde_json::Value) {
if let Ok(env) = std::env::var("COMPOSER_FUND") {
let t = env.trim();
if let Ok(n) = t.parse::<f64>() {
if n == 0.0 {
return;
}
}
}
let funding = installed_packages(project, manifest)
.iter()
.filter(|p| {
p.get("funding")
.and_then(serde_json::Value::as_array)
.is_some_and(|f| !f.is_empty())
})
.count();
if funding > 0 {
eprintln!(
"{funding} package{} you are using {} looking for funding.\nUse the `composer fund` command to find out more!",
if funding == 1 { "" } else { "s" },
if funding == 1 { "is" } else { "are" }
);
}
}
fn resolve_and_lock(
args: &UpdateArgs,
options: vivacity_resolver::session::UpdateOptions,
prefer_stable: bool,
prefer_lowest: bool,
) -> anyhow::Result<Resolved> {
use vivacity_resolver::platform_filter::PlatformRequirementFilter;
use vivacity_resolver::session::UpdateSession;
let t0 = std::time::Instant::now();
let project = project_dir(args.working_dir.as_deref())?;
refuse_alternate_manifest()?;
let manifest_path = project.join("composer.json");
let manifest_text = std::fs::read_to_string(&manifest_path)
.with_context(|| format!("cannot read {}", manifest_path.display()))?;
let installer_dev_mode =
!(args.no_dev || std::env::var("COMPOSER_NO_DEV").is_ok_and(|v| !v.is_empty() && v != "0"));
let mut options = options;
if let Ok(m) = serde_json::from_str::<serde_json::Value>(&manifest_text) {
if let Some(code) = refuse_invalid_root(&m) {
return Ok(Resolved {
status: code,
lock: None,
post: Vec::new(),
manifest: serde_json::Value::Null,
flex_active: false,
thanks_reminder: false,
});
}
refuse_merge_plugin_resolution(&project, &m, !args.no_plugins)?;
let active = vivacity_core::scope::active_plugins(&project, &m, !args.no_plugins)
.iter()
.any(|p| p == vivacity_resolver::merge_plugin::PLUGIN_NAME);
options.merged = merge_root_when(&project, &m, installer_dev_mode, active)
.map_err(|e| anyhow::anyhow!("{e}"))?;
if let Some(merged) = &options.merged {
if !merged.repositories.is_empty() {
anyhow::bail!(
"wikimedia/composer-merge-plugin: {} declares repositories (not emulated at resolution)",
merged.repositories.join(", ")
);
}
}
}
let home = vivacity_core::fetch::composer_home();
let http = http_transport(&project, args.offline)?;
let cache_repo_dir = vivacity_core::fetch::composer_cache_dir().join("repo");
let mut session = match UpdateSession::prepare_update(
&project,
home.as_deref(),
true,
Some(http),
Some(&cache_repo_dir),
&options,
) {
Ok(s) => s,
Err(e)
if matches!(
e.kind,
vivacity_resolver::session::SessionErrorKind::Printed(_)
) =>
{
eprintln!("{}", e.message);
if let Some(line) = &e.stdout {
println!("{line}");
}
let vivacity_resolver::session::SessionErrorKind::Printed(code) = e.kind else {
unreachable!()
};
return Ok(Resolved {
status: code,
lock: None,
post: Vec::new(),
manifest: serde_json::Value::Null,
flex_active: false,
thanks_reminder: false,
});
}
Err(e) => return Err(anyhow::anyhow!("{e}")),
};
trace("prepare", t0);
let mut flex_active = false;
if let Ok(m) = serde_json::from_str::<serde_json::Value>(&manifest_text) {
flex_active = vivacity_core::scope::active_plugins(&project, &m, !args.no_plugins)
.iter()
.any(|p| p == "symfony/flex");
if flex_active {
if let Some(symfony_require) = vivacity_resolver::flex_filter::symfony_require(&m) {
let parsed = vivacity_resolver::constraint::parse_constraints(&symfony_require)
.map_err(|e| {
anyhow::anyhow!("extra.symfony.require {symfony_require:?}: {e}")
})?;
let versions = flex::versions(&project, &m, args.offline)?;
session.flex = Some(vivacity_resolver::session::FlexSession {
symfony_require,
symfony: parsed.constraint,
versions,
});
}
}
}
session.prefer_stable = prefer_stable;
session.prefer_lowest = prefer_lowest;
session.installer_dev_mode = installer_dev_mode;
let env_flag = |name: &str| std::env::var(name).is_ok_and(|v| !v.is_empty() && v != "0");
let ignore_all = args.ignore_platform_reqs || env_flag("COMPOSER_IGNORE_PLATFORM_REQS");
let mut ignore_list = args.ignore_platform_req.clone();
if !ignore_all && ignore_list.is_empty() {
if let Ok(env) = std::env::var("COMPOSER_IGNORE_PLATFORM_REQ") {
if !env.is_empty() {
eprintln!("COMPOSER_IGNORE_PLATFORM_REQ is set to ignore {env}. You may experience unexpected errors.");
ignore_list = env.split(',').map(str::to_owned).collect();
}
}
}
if ignore_all && env_flag("COMPOSER_IGNORE_PLATFORM_REQS") && !args.ignore_platform_reqs {
eprintln!("COMPOSER_IGNORE_PLATFORM_REQS is set. You may experience unexpected errors.");
}
let filter = if ignore_all {
PlatformRequirementFilter::IgnoreAll
} else if !ignore_list.is_empty() {
PlatformRequirementFilter::from_list(&ignore_list)
} else {
PlatformRequirementFilter::IgnoreNothing
};
eprintln!("Loading composer repositories with package information");
let (lock, report) = match session.update(&manifest_text, &filter) {
Ok(r) => r,
Err(e) if e.kind == vivacity_resolver::session::SessionErrorKind::Unsolvable => {
eprintln!("{e}");
return Ok(Resolved {
status: 2,
lock: None,
post: Vec::new(),
manifest: serde_json::Value::Null,
flex_active: false,
thanks_reminder: false,
});
}
Err(e) => return Err(anyhow::anyhow!("{e}")),
};
trace("resolve", t0);
if !args.dry_run && !args.no_install {
if let Ok(m) = serde_json::from_str::<serde_json::Value>(&manifest_text) {
if let Some(reason) =
flex_reinstall_reason(&project, &m, &lock, installer_dev_mode, !args.no_plugins)
{
let code = delegate_resolution(
&project,
vivacity_core::scope::ResolutionCommand::Update,
&[vivacity_core::scope::ScopeIssue::ResolutionPlugin(
"symfony/flex".to_owned(),
reason,
)],
args.no_fallback,
)?;
return Ok(Resolved {
status: code,
lock: None,
post: Vec::new(),
manifest: serde_json::Value::Null,
flex_active: false,
thanks_reminder: false,
});
}
}
}
if flex_active && !args.dry_run {
if let Ok(m) = serde_json::from_str::<serde_json::Value>(&manifest_text) {
let reason = if args.no_install {
None
} else {
flex_install_reason(
&project,
&m,
&lock,
installer_dev_mode,
args.offline,
!args.no_plugins,
)?
}
.or_else(|| flex_sync_reason(&project, &m, &lock));
if let Some(reason) = reason {
let code = delegate_resolution(
&project,
vivacity_core::scope::ResolutionCommand::Update,
&[vivacity_core::scope::ScopeIssue::ResolutionPlugin(
"symfony/flex".to_owned(),
reason,
)],
args.no_fallback,
)?;
return Ok(Resolved {
status: code,
lock: None,
post: Vec::new(),
manifest: serde_json::Value::Null,
flex_active: false,
thanks_reminder: false,
});
}
}
}
let thanks_reminder = flex_active && !args.dry_run && !args.no_install && {
let m: serde_json::Value =
serde_json::from_str(&manifest_text).unwrap_or(serde_json::Value::Null);
let loaded = vivacity_core::scope::active_plugins(&project, &m, !args.no_plugins)
.iter()
.any(|p| p == "symfony/thanks");
let installed = installed_packages(&project, &m);
!loaded
&& vivacity_core::lock::Lock::from_value(&lock)
.wanted_packages(installer_dev_mode)
.any(|p| {
installed.iter().any(|i| {
i.get("name").and_then(serde_json::Value::as_str) == Some(p.name())
}) && !installed_as_locked(&installed, p)
})
};
let lock_path = project.join("composer.lock");
let mut text = vivacity_core::phpjson::php_json_encode_with(
&lock,
vivacity_core::phpjson::FLAGS_JSONFILE,
)?;
let old_text = std::fs::read_to_string(&lock_path).ok();
if let Some(old) = &old_text {
let indent = vivacity_resolver::json_manipulator::detect_indenting(old)
.map_err(|e| anyhow::anyhow!("{e}"))?;
if indent != " " {
text = vivacity_resolver::config_source::reindent(&text, &indent);
}
}
text.push('\n');
let unchanged = old_text.as_deref() == Some(text.as_str());
let write_lock = config_lock_enabled(&manifest_text);
let ops = &report.transaction.transaction.operations;
if ops.is_empty() {
eprintln!("Nothing to modify in lock file");
} else if write_lock {
let count = |f: &dyn Fn(&vivacity_resolver::transaction::Operation) -> bool| {
ops.iter().filter(|o| f(o)).count()
};
use vivacity_resolver::transaction::Operation;
let installs = count(&|o| matches!(o, Operation::Install(_)));
let updates = count(&|o| matches!(o, Operation::Update(..)));
let removals = count(&|o| matches!(o, Operation::Uninstall(_)));
eprintln!(
"Lock file operations: {installs} install{}, {updates} update{}, {removals} removal{}",
if installs == 1 { "" } else { "s" },
if updates == 1 { "" } else { "s" },
if removals == 1 { "" } else { "s" }
);
for line in vivacity_resolver::transaction::lock_operation_lines(&session.arena, ops) {
eprintln!("{line}");
}
}
if write_lock && !args.dry_run {
eprintln!("Writing lock file");
if !unchanged {
std::fs::write(&lock_path, &text)
.with_context(|| format!("cannot write {}", lock_path.display()))?;
}
}
trace("write lock", t0);
let manifest = patched_manifest(&session, &manifest_text);
let fresh_install = !composer_dir_of(&project, &manifest)
.join("installed.json")
.is_file();
let post = post_update_report(&session, ops, &lock, &manifest_text, fresh_install);
Ok(Resolved {
status: 0,
lock: Some(lock),
post,
manifest,
flex_active: flex_active && !args.dry_run,
thanks_reminder,
})
}
fn patched_manifest(
session: &vivacity_resolver::session::UpdateSession,
manifest_text: &str,
) -> serde_json::Value {
let mut manifest: serde_json::Value = serde_json::from_str(manifest_text).unwrap_or_default();
let links_to_object = |links: &vivacity_resolver::package::Links| -> serde_json::Value {
let mut map = serde_json::Map::new();
for l in links.iter() {
map.insert(
l.target.clone(),
serde_json::Value::String(l.pretty_constraint.clone()),
);
}
serde_json::Value::Object(map)
};
if let Some(obj) = manifest.as_object_mut() {
for (key, links) in [
("require", &session.root.package.requires),
("require-dev", &session.root.package.dev_requires),
] {
if links.is_empty() {
obj.remove(key);
} else {
obj.insert(key.to_owned(), links_to_object(links));
}
}
}
manifest
}
fn post_update_report(
session: &vivacity_resolver::session::UpdateSession,
ops: &[vivacity_resolver::transaction::Operation],
lock: &serde_json::Value,
manifest_text: &str,
fresh_install: bool,
) -> Vec<String> {
let mut out: Vec<String> = Vec::new();
use vivacity_resolver::transaction::Operation;
let manifest: serde_json::Value = serde_json::from_str(manifest_text).unwrap_or_default();
let mut suggestions: Vec<(String, String)> = Vec::new();
let add_from =
|suggestions: &mut Vec<(String, String)>, source: &str, raw: &serde_json::Value| {
if let Some(map) = raw.get("suggest").and_then(serde_json::Value::as_object) {
for target in map.keys() {
suggestions.push((source.to_owned(), target.clone()));
}
}
};
for op in ops {
if let Operation::Install(idx) = op {
let p = &session.arena[*idx];
add_from(&mut suggestions, &p.pretty_name, &p.raw);
}
}
if fresh_install {
let root_name = manifest
.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or("__root__");
add_from(&mut suggestions, root_name, &manifest);
}
if !suggestions.is_empty() {
let mut installed_names: std::collections::HashMap<String, Vec<String>> =
std::collections::HashMap::new();
let mut add_names = |name: &str, names: Vec<String>| {
for n in names {
installed_names.entry(n).or_default().push(name.to_owned());
}
};
let mut lock_sections = vec!["packages"];
if session.installer_dev_mode {
lock_sections.push("packages-dev");
}
for section in lock_sections {
for p in lock
.get(section)
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
{
let Some(name) = p.get("name").and_then(serde_json::Value::as_str) else {
continue;
};
let name = name.to_lowercase();
let mut names = vec![name.clone()];
for key in ["provide", "replace"] {
for target in p
.get(key)
.and_then(serde_json::Value::as_object)
.into_iter()
.flat_map(|m| m.keys())
{
if !names.contains(target) {
names.push(target.clone());
}
}
}
add_names(&name, names);
}
}
for &idx in &session.platform {
let p = &session.arena[idx];
add_names(&p.name, p.names(true));
}
let root = &session.root.package;
add_names(&root.name, root.names(true));
let count = suggestions
.iter()
.filter(|(source, target)| {
let source_lower = source.to_lowercase();
!installed_names
.get(target)
.is_some_and(|providers| providers.iter().any(|p| *p != source_lower))
})
.count();
if count > 0 {
out.push(format!(
"{count} package suggestions were added by new dependencies, use `composer suggest` to see details."
));
}
}
out.extend(abandoned_warnings(lock));
out
}
fn abandoned_warnings(lock: &serde_json::Value) -> Vec<String> {
let mut out = Vec::new();
for section in ["packages", "packages-dev"] {
for p in lock
.get(section)
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
{
let abandoned = match p.get("abandoned") {
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Bool(false)) => {
continue
}
Some(serde_json::Value::String(s)) if s.is_empty() || s == "0" => continue,
Some(serde_json::Value::Number(n)) if n.as_f64() == Some(0.0) => continue,
Some(serde_json::Value::Array(a)) if a.is_empty() => continue,
Some(serde_json::Value::Object(o)) if o.is_empty() => continue,
Some(serde_json::Value::String(replacement)) => Some(replacement.clone()),
Some(_) => None,
};
let replacement = match abandoned {
Some(r) => format!("Use {r} instead"),
None => "No replacement was suggested".to_owned(),
};
out.push(format!(
"Package {} is abandoned, you should avoid using it. {replacement}.",
p.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or("")
));
}
}
out
}
fn config_lock_enabled(manifest_text: &str) -> bool {
let manifest: serde_json::Value = serde_json::from_str(manifest_text).unwrap_or_default();
match require::config_value(&manifest, "lock") {
None => true,
Some(serde_json::Value::String(s)) => s != "false" && !(s.is_empty() || s == "0"),
Some(serde_json::Value::Bool(b)) => b,
Some(serde_json::Value::Number(n)) => n.as_f64().is_some_and(|f| f != 0.0),
Some(serde_json::Value::Null) => false,
Some(serde_json::Value::Array(a)) => !a.is_empty(),
Some(serde_json::Value::Object(m)) => !m.is_empty(),
}
}
async fn futures_join_all<F: std::future::Future + Send + 'static>(tasks: Vec<F>) -> Vec<F::Output>
where
F::Output: Send + 'static,
{
let handles: Vec<_> = tasks.into_iter().map(tokio::spawn).collect();
let mut out = Vec::with_capacity(handles.len());
for h in handles {
out.push(h.await.expect("metadata task panicked"));
}
out
}
fn run_remove(args: &RemoveArgs) -> anyhow::Result<i32> {
use vivacity_resolver::config_source::{composer_file, JsonConfigSource};
let env_flag = |name: &str| std::env::var(name).is_ok_and(|v| !v.is_empty() && v != "0");
if args.minimal_changes || env_flag("COMPOSER_MINIMAL_CHANGES") {
anyhow::bail!("`--minimal-changes` (update-with-minimal-changes) is not supported yet");
}
let dry_run = args.dry_run;
let mut to_remove: Vec<(bool, String)> = Vec::new();
if args.packages.is_empty() && !args.unused {
eprintln!("Not enough arguments (missing: \"packages\").");
return Ok(1);
}
let project = project_dir(args.working_dir.as_deref())?;
let file = composer_file(&project);
let file_label = match std::env::var("COMPOSER").ok().map(|f| f.trim().to_owned()) {
Some(f) if !f.is_empty() && f != "composer.json" && f != "./composer.json" => {
anyhow::bail!("COMPOSER={f}: an alternate manifest is not supported yet");
}
Some(f) if !f.is_empty() => f,
_ => "./composer.json".to_owned(),
};
let manifest_text = std::fs::read_to_string(&file)
.with_context(|| format!("cannot read {}", file.display()))?;
let manifest: serde_json::Value = serde_json::from_str(&manifest_text)
.with_context(|| format!("{} does not contain valid JSON", file.display()))?;
if let Some(code) = refuse_invalid_root(&manifest) {
return Ok(code);
}
refuse_merge_plugin_resolution(&project, &manifest, !args.no_plugins)?;
if serde_json::from_str::<serde_json::Value>(&manifest_text)
.ok()
.and_then(|m| m.get("config")?.get("update-with-minimal-changes").cloned())
.is_some_and(|v| v == serde_json::Value::Bool(true))
{
anyhow::bail!("config.update-with-minimal-changes is not supported yet");
}
let mut packages: Vec<String> = args.packages.iter().map(|p| p.to_lowercase()).collect();
let locked_data: Option<serde_json::Value> =
std::fs::read_to_string(project.join("composer.lock"))
.ok()
.and_then(|t| serde_json::from_str(&t).ok())
.filter(|v: &serde_json::Value| v.get("packages").is_some());
if args.unused {
let lock = locked_data.clone().ok_or_else(|| {
anyhow::anyhow!(
"A valid composer.lock file is required to run this command with --unused"
)
})?;
packages.extend(unused_locked_packages(&manifest, &lock));
if packages.is_empty() {
eprintln!("No unused packages to remove");
return Ok(0);
}
}
if let Some(code) = resolution_fallback(
&project,
&manifest,
vivacity_core::scope::ResolutionCommand::Remove,
args.no_plugins,
args.no_fallback,
!args.no_install && !args.dry_run,
)? {
return Ok(code);
}
let backup = manifest_text.clone();
let json = JsonConfigSource::new(&file);
let (link_type, alt_type) = if args.dev {
("require-dev", "require")
} else {
("require", "require-dev")
};
if args.update_with_dependencies {
eprintln!("You are using the deprecated option \"update-with-dependencies\". This is now default behaviour. The --no-update-with-dependencies option can be used to remove a package without its dependencies.");
}
let keyed = |section: &str| -> Vec<(String, String)> {
let mut keys: Vec<(String, String)> = Vec::new();
if let Some(m) = manifest.get(section).and_then(|v| v.as_object()) {
for k in m.keys() {
keys.push((k.clone(), k.clone()));
}
for k in m.keys() {
let lower = k.to_lowercase();
match keys.iter_mut().find(|(key, _)| *key == lower) {
Some(entry) => entry.1 = k.clone(),
None => keys.push((lower, k.clone())),
}
}
}
keys
};
let sections = [(link_type, keyed(link_type)), (alt_type, keyed(alt_type))];
let lookup = |section: &str, key: &str| -> Option<String> {
sections
.iter()
.find(|(s, _)| *s == section)?
.1
.iter()
.find(|(k, _)| k == key)
.map(|(_, name)| name.clone())
};
let grep = |section: &str, pattern: &str| -> Vec<String> {
let re = vivacity_resolver::pool::package_name_regexp(pattern);
sections
.iter()
.find(|(s, _)| *s == section)
.map(|(_, keys)| {
keys.iter()
.filter(|(k, _)| re.is_match(k.as_bytes()).unwrap_or(false))
.map(|(k, _)| k.clone())
.collect()
})
.unwrap_or_default()
};
let has_section = |section: &str| manifest.get(section).is_some_and(|v| !v.is_null());
let dev_key = link_type == "require-dev";
for package in &packages {
if let Some(name) = lookup(link_type, package) {
if dry_run {
to_remove.push((dev_key, name));
} else {
json.remove_link(link_type, &name)
.map_err(|e| anyhow::anyhow!("{e}"))?;
}
} else if let Some(name) = lookup(alt_type, package) {
eprintln!("{name} could not be found in {link_type} but it is present in {alt_type}");
} else if has_section(link_type) && !grep(link_type, package).is_empty() {
for matched in grep(link_type, package) {
if dry_run {
to_remove.push((dev_key, matched));
} else {
json.remove_link(link_type, &matched)
.map_err(|e| anyhow::anyhow!("{e}"))?;
}
}
} else if has_section(alt_type) && !grep(alt_type, package).is_empty() {
for matched in grep(alt_type, package) {
eprintln!(
"{matched} could not be found in {link_type} but it is present in {alt_type}"
);
}
} else {
eprintln!("{package} is not required in your composer.json and has not been removed");
}
}
eprintln!("{file_label} has been updated");
if args.no_update {
return Ok(0);
}
let updated: serde_json::Value = std::fs::read_to_string(&file)
.ok()
.and_then(|t| serde_json::from_str(&t).ok())
.unwrap_or(serde_json::Value::Null);
if let (false, Some(serde_json::Value::Object(allow))) = (
dry_run,
vivacity_core::layout::merged_allow_plugins(
updated.get("config").and_then(|c| c.get("allow-plugins")),
vivacity_core::layout::global_allow_plugins().as_ref(),
),
) {
let removed: Vec<&String> = allow.keys().filter(|k| packages.contains(k)).collect();
if !removed.is_empty() {
if removed.len() == allow.len() {
json.remove_config_setting("allow-plugins")
.map_err(|e| anyhow::anyhow!("{e}"))?;
} else {
for plugin in removed {
json.remove_config_setting(&format!("allow-plugins.{plugin}"))
.map_err(|e| anyhow::anyhow!("{e}"))?;
}
}
}
}
let transitive = if args.update_with_all_dependencies
|| args.with_all_dependencies
|| env_flag("COMPOSER_WITH_ALL_DEPENDENCIES")
{
vivacity_resolver::pool::UpdateMode::ListedWithTransitiveDeps
} else if args.no_update_with_dependencies {
vivacity_resolver::pool::UpdateMode::OnlyListed
} else {
vivacity_resolver::pool::UpdateMode::ListedWithTransitiveDepsNoRootRequire
};
let mut flags = String::new();
if transitive == vivacity_resolver::pool::UpdateMode::ListedWithTransitiveDeps {
flags.push_str(" --with-all-dependencies");
} else if transitive == vivacity_resolver::pool::UpdateMode::OnlyListed {
flags.push_str(" --with-dependencies");
}
eprintln!("Running composer update {}{flags}", packages.join(" "));
let mut options = if locked_data.is_some() {
vivacity_resolver::session::UpdateOptions::partial(&packages, transitive)
} else {
vivacity_resolver::session::UpdateOptions::default()
};
options.no_blocking = args.no_blocking || args.no_security_blocking;
if dry_run {
options.root_patch = Some(vivacity_resolver::root::RootPatch {
removals: to_remove,
..Default::default()
});
}
let update_args = UpdateArgs {
no_progress: args.no_progress,
with: Vec::new(),
packages: Vec::new(),
with_dependencies: false,
with_all_dependencies: false,
no_install: args.no_install,
dry_run: args.dry_run,
no_dev: args.update_no_dev || env_flag("COMPOSER_NO_DEV"),
no_autoloader: args.no_autoloader,
optimize_autoloader: args.optimize_autoloader,
classmap_authoritative: args.classmap_authoritative,
apcu_autoloader: args.apcu_autoloader,
apcu_autoloader_prefix: args.apcu_autoloader_prefix.clone(),
no_scripts: args.no_scripts,
no_plugins: args.no_plugins,
no_audit: args.no_audit,
no_blocking: args.no_blocking,
no_security_blocking: args.no_security_blocking,
prefer_stable: false,
prefer_lowest: false,
ignore_platform_reqs: args.ignore_platform_reqs,
ignore_platform_req: args.ignore_platform_req.clone(),
no_fallback: args.no_fallback,
offline: args.offline,
working_dir: args.working_dir.clone(),
spawn_fallback: true,
};
let status = run_update_resolved(&update_args, options, false, false)?;
if status != 0 {
eprintln!("\nRemoval failed, reverting {file_label} to its original content.");
std::fs::write(&file, &backup)
.with_context(|| format!("cannot restore {}", file.display()))?;
}
if dry_run {
return Ok(status);
}
for package in &packages {
if locally_installed(&project, &manifest, package) {
eprintln!("Removal failed, {package} is still present, it may be required by another package. See `composer why {package}`.");
return Ok(2);
}
}
Ok(status)
}
fn locally_installed(project: &std::path::Path, manifest: &serde_json::Value, name: &str) -> bool {
installed_packages(project, manifest)
.iter()
.any(|p| p.get("name").and_then(|n| n.as_str()) == Some(name))
}
fn missing_requirement_info(
manifest: &serde_json::Value,
lock: &serde_json::Value,
include_dev: bool,
root_version: &str,
root_pretty_version: &str,
merged_links: Option<(
&[vivacity_resolver::merge_plugin::MergedLink],
&[vivacity_resolver::merge_plugin::MergedLink],
)>,
) -> anyhow::Result<Vec<String>> {
use vivacity_resolver::constraint::{parse_constraints, Constraint, Op};
use vivacity_resolver::package::{Origin, Package};
let mut out = Vec::new();
let mut missing = false;
let root_name = manifest
.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or("__root__")
.to_lowercase();
let root_links: Vec<(String, Constraint, String, &str)> =
[("replace", "replaced"), ("provide", "provided")]
.iter()
.flat_map(|(key, word)| {
manifest
.get(*key)
.and_then(serde_json::Value::as_object)
.into_iter()
.flat_map(|m| m.iter())
.filter_map(move |(t, c)| {
let text = c.as_str()?;
let source = if text == "self.version" {
root_version
} else {
text
};
Some((
t.to_lowercase(),
parse_constraints(source).ok()?.constraint,
text.to_owned(),
*word,
))
})
})
.collect();
let root_eq = Constraint::new(Op::Eq, root_version);
let mut sets: Vec<(bool, &str, &str)> = vec![(false, "require", "Required")];
if include_dev {
sets.push((true, "require-dev", "Required (in require-dev)"));
}
for (with_dev, key, description) in sets {
let mut arena: Vec<Package> = Vec::new();
let repo =
vivacity_resolver::repository::locked_repository_with(lock, &mut arena, with_dev)
.map_err(|e| anyhow::anyhow!("composer.lock: {}", e.0))?;
let links: Vec<(String, String, Constraint)> = match merged_links {
Some((req, dev)) => (if with_dev { dev } else { req })
.iter()
.map(|l| (l.target.clone(), l.pretty.clone(), l.constraint.clone()))
.collect(),
None => {
let Some(map) = manifest.get(key).and_then(serde_json::Value::as_object) else {
continue;
};
map.iter()
.filter_map(|(target, pretty)| {
let pretty = pretty.as_str()?;
let parsed = parse_constraints(pretty).ok()?;
Some((target.to_lowercase(), pretty.to_owned(), parsed.constraint))
})
.collect()
}
};
for (target, pretty, constraint) in links {
let pretty = pretty.as_str();
if vivacity_resolver::platform::is_platform_package(&target) || pretty == "self.version"
{
continue;
}
let parsed = vivacity_resolver::constraint::ParsedConstraint {
constraint,
pretty: pretty.to_owned(),
};
let matches = |idx: usize, constraint: Option<&Constraint>| -> bool {
let p = &arena[idx];
if p.name == target {
return constraint
.is_none_or(|c| c.matches(&Constraint::new(Op::Eq, p.version.clone())));
}
p.replaces.iter().chain(p.provides.iter()).any(|l| {
l.target == target && constraint.is_none_or(|c| c.matches(&l.constraint))
})
};
let root_matches = |constraint: Option<&Constraint>| -> bool {
if root_name == target {
return constraint.is_none_or(|c| c.matches(&root_eq));
}
root_links
.iter()
.any(|(t, lc, _, _)| *t == target && constraint.is_none_or(|c| c.matches(lc)))
};
if repo.iter().any(|&i| matches(i, Some(&parsed.constraint)))
|| root_matches(Some(&parsed.constraint))
{
continue;
}
let any: Option<usize> = repo.iter().copied().find(|&i| matches(i, None));
let line = match any {
Some(idx) => {
let p = &arena[idx];
let mut description_text = p.pretty_version.clone();
if p.name != target {
for (links, text) in [
(&p.replaces, "replaced as {} by {}"),
(&p.provides, "provided as {} by {}"),
] {
if let Some(l) = links.iter().find(|l| l.target == target) {
description_text =
text.replacen("{}", &l.pretty_constraint, 1).replacen(
"{}",
&format!("{} {}", p.pretty_name, p.pretty_version),
1,
);
break;
}
}
}
format!("- {description} package \"{target}\" is in the lock file as \"{description_text}\" but that does not satisfy your constraint \"{pretty}\".")
}
None if root_matches(None) => {
let root_name_pretty = manifest
.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or("__root__");
let description_text = if root_name == target {
root_pretty_version.to_owned()
} else {
match root_links.iter().find(|(t, _, _, _)| *t == target) {
Some((_, _, pc, word)) => {
format!(
"{word} as {pc} by {root_name_pretty} {root_pretty_version}"
)
}
None => root_pretty_version.to_owned(),
}
};
format!("- {description} package \"{target}\" is in the lock file as \"{description_text}\" but that does not satisfy your constraint \"{pretty}\".")
}
None => {
format!("- {description} package \"{target}\" is not present in the lock file.")
}
};
out.push(line);
missing = true;
}
let _ = Origin::Locked;
}
if missing {
out.push("This usually happens when composer files are incorrectly merged or the composer.json file is manually edited.".to_owned());
out.push("Read more about correctly resolving merge conflicts https://getcomposer.org/doc/articles/resolving-merge-conflicts.md".to_owned());
out.push("and prefer using the \"require\" command over editing the composer.json file directly https://getcomposer.org/doc/03-cli.md#require-r".to_owned());
}
Ok(out)
}
fn unused_locked_packages(manifest: &serde_json::Value, lock: &serde_json::Value) -> Vec<String> {
use std::collections::BTreeSet;
let mut required: BTreeSet<String> = BTreeSet::new();
for section in ["require", "require-dev"] {
if let Some(m) = manifest.get(section).and_then(|v| v.as_object()) {
required.extend(m.keys().map(|k| k.to_lowercase()));
}
}
let mut locked: Vec<&serde_json::Value> = lock
.get("packages")
.and_then(|p| p.as_array())
.map(|a| a.iter().collect())
.unwrap_or_default();
let names = |p: &serde_json::Value| -> Vec<String> {
let mut out = vec![p
.get("name")
.and_then(|n| n.as_str())
.unwrap_or("")
.to_lowercase()];
for key in ["replace", "provide"] {
if let Some(m) = p.get(key).and_then(|v| v.as_object()) {
out.extend(m.keys().map(|k| k.to_lowercase()));
}
}
out
};
loop {
let mut found = false;
let mut i = 0;
while i < locked.len() {
let p = locked[i];
if names(p).iter().any(|n| required.contains(n)) {
if let Some(m) = p.get("require").and_then(|v| v.as_object()) {
required.extend(m.keys().map(|k| k.to_lowercase()));
}
found = true;
locked.remove(i);
} else {
i += 1;
}
}
if !found {
break;
}
}
locked
.iter()
.map(|p| {
p.get("name")
.and_then(|n| n.as_str())
.unwrap_or("")
.to_lowercase()
})
.collect()
}
#[cfg(test)]
mod temporary_requirement_tests {
use super::{package_of_requirement, temporary_requirements};
fn v(list: &[&str]) -> Vec<String> {
list.iter().map(|s| (*s).to_owned()).collect()
}
#[test]
fn parses_the_three_forms_and_the_shorthand() {
let reqs =
temporary_requirements(&v(&["a/b:^1", "c/d=^2", "e/f ^3"]), &[]).expect("parsed");
assert_eq!(
reqs,
vec![
("a/b".to_owned(), "^1".to_owned()),
("c/d".to_owned(), "^2".to_owned()),
("e/f".to_owned(), "^3".to_owned())
]
);
let reqs = temporary_requirements(&[], &v(&["a/b:^1", "c/d"])).expect("parsed");
assert_eq!(reqs, vec![("a/b".to_owned(), "^1".to_owned())]);
let reqs = temporary_requirements(&v(&["a/b:^1"]), &v(&["a/b:^2"])).expect("parsed");
assert_eq!(reqs, vec![("a/b".to_owned(), "^2".to_owned())]);
assert_eq!(package_of_requirement("a/b:^1"), "a/b");
assert_eq!(package_of_requirement("a/b=^1"), "a/b");
assert_eq!(package_of_requirement("a/b ^1"), "a/b");
assert_eq!(package_of_requirement("a/b"), "a/b");
assert_eq!(package_of_requirement("a/*"), "a/*");
}
#[test]
fn a_pair_without_a_version_is_an_error() {
let e = temporary_requirements(&v(&["a/b"]), &[])
.unwrap_err()
.to_string();
assert_eq!(
e,
"Option a/b is missing a version constraint, use e.g. a/b:^1.0"
);
}
}
#[cfg(test)]
mod local_repository_tests {
use super::unchanged_local_repository;
use serde_json::{json, Value};
fn pkg(name: &str, version: &str) -> Value {
json!({"name": name, "version": version, "dist": {"reference": "abc"}})
}
fn lock(packages: Vec<Value>, dev: Vec<Value>) -> Value {
json!({"packages": packages, "packages-dev": dev, "aliases": []})
}
#[test]
fn accepts_only_a_truly_unchanged_repository() {
let installed = vec![pkg("a/b", "1.0.0"), pkg("c/d", "2.0.0")];
let l = lock(vec![pkg("a/b", "1.0.0")], vec![pkg("c/d", "2.0.0")]);
assert_eq!(
unchanged_local_repository(&installed, &l, true),
Some(vec!["a/b".to_owned(), "c/d".to_owned()]),
"same packages, same versions and references"
);
assert!(unchanged_local_repository(&installed, &l, false).is_none());
}
#[test]
fn declines_every_difference_the_transaction_would_see() {
let installed = vec![pkg("a/b", "1.0.0")];
let same = || vec![pkg("a/b", "1.0.0")];
let decline = |packages: Vec<Value>, why: &str| {
assert!(
unchanged_local_repository(&installed, &lock(packages, vec![]), true).is_none(),
"{why}"
);
};
decline(vec![pkg("a/b", "1.1.0")], "a new version is an update");
decline(
vec![json!({"name": "a/b", "version": "1.0.0", "dist": {"reference": "zzz"}})],
"a new dist reference is an update",
);
decline(
vec![
json!({"name": "a/b", "version": "1.0.0", "dist": {"reference": "abc"}, "source": {"reference": "s"}}),
],
"a new source reference is an update",
);
decline(
vec![
json!({"name": "a/b", "version": "1.0.0", "dist": {"reference": "abc"}, "abandoned": true}),
],
"becoming abandoned is an update",
);
decline(
vec![pkg("e/f", "1.0.0")],
"another package is install + uninstall",
);
decline(vec![], "an empty lock uninstalls");
decline(
vec![pkg("a/b", "1.0.0"), pkg("e/f", "1.0.0")],
"one more package is an install",
);
let mut aliased = lock(same(), vec![]);
aliased["aliases"] =
json!([{"package": "a/b", "alias": "1.0", "alias_normalized": "1.0.0.0"}]);
assert!(unchanged_local_repository(&installed, &aliased, true).is_none());
let dev_alias = json!({"name": "a/b", "version": "dev-main", "dist": {"reference": "abc"},
"extra": {"branch-alias": {"dev-main": "1.x-dev"}}});
assert!(
unchanged_local_repository(
std::slice::from_ref(&dev_alias),
&lock(vec![dev_alias.clone()], vec![]),
true
)
.is_none(),
"a dev version with a branch-alias grows an alias package"
);
let stable_extra = json!({"name": "a/b", "version": "1.0.0", "dist": {"reference": "abc"},
"extra": {"branch-alias": {"dev-main": "1.x-dev"}}});
assert!(unchanged_local_repository(
std::slice::from_ref(&stable_extra),
&lock(vec![stable_extra.clone()], vec![]),
true
)
.is_some());
assert!(
unchanged_local_repository(&installed, &json!({"packages": same()}), true).is_none()
);
}
}
#[cfg(test)]
mod flex_sync_tests {
use super::flex_ux_package;
#[test]
fn ux_package_found_in_either_lock_section() {
let lock = serde_json::json!({
"packages": [
{"name": "psr/log", "keywords": ["log"]},
{"name": "symfony/ux-icons", "keywords": ["icons", "symfony-ux"]},
],
"packages-dev": [{"name": "symfony/stimulus-bundle", "keywords": ["symfony-ux"]}],
});
assert_eq!(flex_ux_package(&lock), Some("symfony/ux-icons"));
let dev_only = serde_json::json!({
"packages": [{"name": "psr/log"}],
"packages-dev": [{"name": "symfony/stimulus-bundle", "keywords": ["symfony-ux"]}],
});
assert_eq!(flex_ux_package(&dev_only), Some("symfony/stimulus-bundle"));
assert_eq!(flex_ux_package(&serde_json::json!({})), None);
}
}