use super::*;
fn say_lock_resolution(sat: std::time::Duration) {
vivacity_core::say_verbose!(
"Dependency resolution completed in {:.3} seconds",
sat.as_secs_f64()
);
}
type Flow<T = ()> = std::ops::ControlFlow<i32, T>;
macro_rules! proceed {
($flow:expr) => {
match $flow {
std::ops::ControlFlow::Continue(value) => value,
std::ops::ControlFlow::Break(code) => return Ok(code),
}
};
}
pub(crate) fn run_install(args: &InstallArgs) -> anyhow::Result<i32> {
if !args.after_update() {
if let Ok(project) = project_dir(args.working_dir.as_deref()) {
hold_root_version_warning(&project);
hold_ignored_lock_warning(&project);
}
}
let run = proceed!(read_manifests(args)?);
let run = proceed!(merge_plugin(run)?);
if !args.after_update() && !args.dry_run {
if let Some(reason) = insecure_dist_reason(
&run.project,
&run.manifest,
&run.lock,
run.with_dev,
!args.no_plugins,
) {
let scope = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(reason)],
skipped_plugins: vec![],
layout: None,
};
return fallback_or_fail(args, &scope);
}
}
if !args.after_update() {
if let Some(reason) = crate::fallback::local_install_issue(&run.manifest) {
let scope = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(reason)],
skipped_plugins: vec![],
layout: None,
};
return fallback_or_fail(args, &scope);
}
}
if !args.after_update() {
bamarni_command_event(&run.project, &run.manifest, !args.no_plugins);
}
let run = proceed!(pre_install_cmd(run)?);
if crate::fallback::hold_trigger(&run.manifest) {
crate::fallback::start_holding("the downloads end");
}
proceed!(headline(&run)?);
let verification = spawn_verification(&run)?;
let root = verification.as_ref().map(|v| root_package(&run, v));
let tx = local_repository_transaction(&run, root.as_ref())?;
let mut scope = analyze_scope(&run);
if let Some(report) = scope
.as_mut()
.filter(|_| !args.after_update() && !args.no_plugins)
{
let targets: Vec<(String, bool)> =
crate::plugin_allow::installed_by(&run.project, &run.manifest, &run.lock, run.with_dev);
report.issues.extend(crate::plugin_allow::install_issue(
&run.project,
&run.manifest,
targets.iter().map(|(n, o)| (n.as_str(), *o)),
));
}
let early_dump = plan_autoload_early(&run, &tx, scope.as_ref());
if let Some(verification) = verification {
let mut verification = verification;
proceed!(report_missing(&run, &tx.missing, &mut verification)?);
proceed!(join_verification(&run, verification)?);
}
report_operations(&tx);
if args.dry_run {
return dry_run(&run, &tx);
}
let layout = proceed!(native_layout(&run, scope)?);
if !args.after_update() {
crate::effect_plugins::patcher_pre(
&run.project,
&run.manifest,
&layout,
run.with_dev,
!args.no_plugins,
)?;
}
vivacity_core::signals::suspend();
let executed = execute_operations(&run, &tx, &layout);
vivacity_core::signals::resume();
let installed = proceed!(executed?);
let (autoload_note, cleaner_counts) = if args.no_autoloader {
(String::new(), None)
} else {
proceed!(dump_autoloader(
&run,
&tx,
&layout,
&installed.report,
early_dump
)?)
};
proceed!(post_install(
&run,
&layout,
&installed.report,
&tx,
cleaner_counts.as_ref()
)?);
say_summary(&run, &installed.report, &autoload_note);
Ok(0)
}
struct Run<'a> {
args: &'a InstallArgs,
t0: std::time::Instant,
project: PathBuf,
manifest_text: String,
manifest: serde_json::Value,
merged: Option<vivacity_resolver::merge_plugin::Merged>,
lock_value: serde_json::Value,
lock: vivacity_core::lock::Lock,
with_dev: bool,
ignore_platform_reqs: bool,
ignore_platform_req: Vec<String>,
runner: Option<scripts::Runner>,
}
fn read_manifests(args: &InstallArgs) -> anyhow::Result<Flow<Run<'_>>> {
let (ignore_platform_reqs, ignore_platform_req) = platform_requirement_options(args);
if args.no_install {
vivacity_core::say!("Invalid option \"--no-install\". Use \"composer update --no-install\" instead if you are trying to update the composer.lock file.");
return Ok(Flow::Break(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()?;
if let Some(code) = refuse_missing_manifest(&project) {
return Ok(Flow::Break(code));
}
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(Flow::Break(code));
}
if !args.after_update() {
if let Some(code) = crate::plugin_allow::at_load(
&project,
&manifest,
None,
!args.no_plugins,
args.no_fallback,
)? {
return Ok(Flow::Break(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) => {
vivacity_core::say_always!("{message}");
return Ok(Flow::Break(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) => {}
}
if let Some(allow) = args
.post_update
.as_ref()
.and_then(|u| u.allow_plugins_at_load.clone())
{
if let Some(root) = manifest.as_object_mut() {
let config = root
.entry("config")
.or_insert_with(|| serde_json::json!({}));
if let Some(config) = config.as_object_mut() {
config.insert("allow-plugins".to_owned(), allow);
}
}
}
let manifest = manifest;
let lock_value: serde_json::Value = match &args.virtual_lock {
Some(v) => serde_json::from_str(&vivacity_core::phpjson::php_json_encode_with(
v,
vivacity_core::phpjson::FLAGS_JSONFILE,
)?)
.context("invalid composer.lock")?,
None => {
let enabled = config_lock_enabled(&manifest_text);
let text = match std::fs::read_to_string(&lock_path) {
Ok(text) if enabled => text,
Err(e) if enabled && e.kind() != std::io::ErrorKind::NotFound => {
return Err(anyhow::Error::new(e)
.context(format!("cannot read {}", lock_path.display())));
}
_ => return Ok(Flow::Break(install_without_lock(args, enabled)?)),
};
let value: serde_json::Value =
serde_json::from_str(&text).context("invalid composer.lock")?;
if !value.get("packages").is_some_and(|p| !p.is_null()) {
return Ok(Flow::Break(install_without_lock(args, enabled)?));
}
value
}
};
let lock = vivacity_core::lock::Lock::from_value(&lock_value);
trace("read manifests", t0);
let with_dev = !args.no_dev && !env_no_dev();
Ok(Flow::Continue(Run {
args,
t0,
project,
manifest_text,
manifest,
merged: None,
lock_value,
lock,
with_dev,
ignore_platform_reqs,
ignore_platform_req,
runner: None,
}))
}
fn install_without_lock(args: &InstallArgs, lock_enabled: bool) -> anyhow::Result<i32> {
let line = format!(
"{} Updating dependencies to latest instead of installing from lock file. See https://getcomposer.org/install for more information.",
if lock_enabled {
"No composer.lock file present."
} else {
"Lockfile creation is disabled in config."
}
);
if args.check_scope || args.run_scripts {
let report = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(format!(
"no lock to install: Composer resolves instead ({})",
if lock_enabled {
"no composer.lock"
} else {
"config.lock is false"
}
))],
..Default::default()
};
return fallback_or_fail(args, &report);
}
if vivacity_core::io::level() == vivacity_core::io::Verbosity::Verbose
&& !args.no_plugins
&& !args.dry_run
{
vivacity_core::io::defer();
}
let project = project_dir(args.working_dir.as_deref())?;
let manifest: serde_json::Value =
serde_json::from_str(&std::fs::read_to_string(project.join("composer.json"))?)
.context("invalid composer.json")?;
if let Some(code) = resolution_fallback(
&project,
&manifest,
vivacity_core::scope::ResolutionCommand::Update,
args.no_plugins,
args.no_fallback,
!args.dry_run,
!args.dry_run,
!(args.no_dev || env_no_dev()),
&PoolStart::default(),
)? {
return Ok(code);
}
let update_args = UpdateArgs {
minimal_changes: false,
compat: GlobalCompatArgs {
no_interaction: args.compat.no_interaction,
no_ansi: args.compat.no_ansi,
..GlobalCompatArgs::default()
},
no_progress: args.no_progress,
packages: Vec::new(),
with: Vec::new(),
with_dependencies: false,
with_all_dependencies: false,
no_install: false,
dry_run: args.dry_run,
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,
no_plugins: args.no_plugins,
no_audit: true,
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(),
prefer_source: args.prefer_source,
prefer_dist: args.prefer_dist,
prefer_install: args.prefer_install.clone(),
command_dispatched: false,
lockless_install: Some(line),
allow_plugins_at_load: None,
resolution_command: None,
};
let options = vivacity_resolver::session::UpdateOptions {
no_blocking: args.no_blocking || args.no_security_blocking,
..Default::default()
};
run_update_resolved(&update_args, options, false, false, &|| Ok(())).map(|e| e.status)
}
fn platform_requirement_options(args: &InstallArgs) -> (bool, Vec<String>) {
platform_requirement_env(
args.ignore_platform_reqs,
&args.ignore_platform_req,
!args.after_update(),
)
}
fn merge_plugin(run: Run<'_>) -> anyhow::Result<Flow<Run<'_>>> {
let merged = match merge_plugin_root(
&run.project,
&run.lock,
&run.manifest,
run.with_dev,
!run.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 Ok(Flow::Break(fallback_or_fail(run.args, &report)?));
}
};
let manifest = match &merged {
Some(m) => m.manifest.clone(),
None => run.manifest,
};
Ok(Flow::Continue(Run {
manifest,
merged,
..run
}))
}
fn pre_install_cmd(run: Run<'_>) -> anyhow::Result<Flow<Run<'_>>> {
let args = run.args;
let runner = if args.run_scripts && !args.no_scripts {
match scripts::Runner::new(&run.project, &run.manifest, run.with_dev, which_composer()) {
Ok(r) => r,
Err(e) => {
vivacity_core::say_always!("vivacity: {e}");
return Ok(Flow::Break(3));
}
}
} else {
None
};
if runner.is_some() {
if let Some(issue) = crate::effect_plugins::replay_issue(
&run.manifest,
&run.lock,
run.with_dev,
!args.no_plugins,
true,
&[
scripts::PRE_INSTALL_CMD,
scripts::POST_INSTALL_CMD,
scripts::PRE_AUTOLOAD_DUMP,
scripts::POST_AUTOLOAD_DUMP,
],
) {
let report = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(issue)],
..Default::default()
};
return Ok(Flow::Break(fallback_or_fail(args, &report)?));
}
}
if let Some(r) = &runner {
let code = r.run(scripts::PRE_INSTALL_CMD)?;
if code != 0 {
return Ok(Flow::Break(code));
}
}
Ok(Flow::Continue(Run { runner, ..run }))
}
pub(crate) fn bamarni_command_event(
project: &std::path::Path,
manifest: &serde_json::Value,
plugins_enabled: bool,
) {
let composer_dir = composer_dir_of(project, manifest);
let loaded = plugins_enabled
&& plugin_order::loaded_plugins(
&plugin_order::installed_json_packages(&composer_dir),
&composer_dir,
plugin_order::global_composer_dir().as_deref(),
)
.iter()
.any(|p| p == vivacity_core::bamarni_bin::PLUGIN_NAME);
if loaded
&& vivacity_core::scope::active_plugins(project, manifest, plugins_enabled)
.iter()
.any(|p| p == vivacity_core::bamarni_bin::PLUGIN_NAME)
{
crate::verbose_listeners::announce(
vivacity_core::bamarni_bin::PLUGIN_NAME,
crate::verbose_listeners::COMMAND,
manifest,
);
vivacity_core::say_verbose!("[bamarni-bin] Calling onCommandEvent().");
if let Ok(cfg) = vivacity_core::bamarni_bin::config(manifest.get("extra")) {
vivacity_core::bamarni_bin::print_deprecations(&cfg);
}
}
}
fn headline(run: &Run<'_>) -> anyhow::Result<Flow> {
let config_lock = config_lock_enabled(&run.manifest_text);
if config_lock {
vivacity_core::say!(
"Installing dependencies from lock file{}",
if run.with_dev {
" (including require-dev)"
} else {
""
}
);
}
if run.with_dev && !run.args.after_update() {
refuse_lock_without_dev(run)?;
}
if !run.args.after_update() {
vivacity_core::say!("Verifying lock file contents can be installed on current platform.");
if let (Ok(actual), Some(expected)) = (
vivacity_core::content_hash::content_hash(&run.manifest_text),
run.lock.content_hash.as_deref(),
) {
if actual != expected {
vivacity_core::say_always!(
"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>`."
);
}
}
}
Ok(Flow::Continue(()))
}
fn refuse_lock_without_dev(run: &Run<'_>) -> anyhow::Result<()> {
if run
.lock_value
.get("packages-dev")
.is_none_or(serde_json::Value::is_null)
{
return Err(anyhow::Error::new(ComposerException(
vivacity_resolver::repository::LOCK_WITHOUT_DEV.to_owned(),
)));
}
Ok(())
}
struct Verification {
handle: Option<
std::thread::JoinHandle<
Result<
vivacity_resolver::session::InstallVerification,
vivacity_resolver::session::SessionError,
>,
>,
>,
root_version: Option<std::sync::mpsc::Sender<vivacity_core::root_version::RootVersion>>,
abandoned: std::sync::Arc<std::sync::atomic::AtomicBool>,
ignores_all: bool,
lock_platform: bool,
}
impl Verification {
fn abandon(&self) {
self.abandoned
.store(true, std::sync::atomic::Ordering::Relaxed);
}
fn abandon_and_wait(&mut self) {
self.abandon();
drop(self.root_version.take());
if let Some(handle) = self.handle.take() {
let _ = handle.join();
}
}
}
impl Drop for Verification {
fn drop(&mut self) {
if self.handle.is_some() {
self.abandon();
}
}
}
fn spawn_verification(run: &Run<'_>) -> anyhow::Result<Option<Verification>> {
let args = run.args;
if args.after_update() {
return Ok(None);
}
let abandoned = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let input = vivacity_resolver::session::InstallVerifyInput {
project_dir: run.project.clone(),
composer_home: vivacity_core::fetch::composer_home(),
http: Some(http_transport(&run.project, args.offline)?),
cache_repo_dir: Some(vivacity_core::fetch::composer_cache_dir().join("repo")),
manifest_text: run.manifest_text.clone(),
root_manifest: run.manifest.clone(),
dev_mode: run.with_dev,
no_blocking: args.no_blocking || args.no_security_blocking,
ignore_platform_reqs: run.ignore_platform_reqs,
ignore_platform_req: run.ignore_platform_req.clone(),
prepended_repositories: run
.merged
.as_ref()
.filter(|_| {
installed_packages(&run.project, &run.manifest)
.iter()
.any(|p| {
p.get("name").and_then(serde_json::Value::as_str)
== Some(vivacity_resolver::merge_plugin::PLUGIN_NAME)
})
})
.map(|m| m.repository_definitions.clone())
.unwrap_or_default(),
abandoned: abandoned.clone(),
};
let (root_version, received) = std::sync::mpsc::channel();
let handle =
std::thread::spawn(move || vivacity_resolver::session::verify_install(input, received));
Ok(Some(Verification {
handle: Some(handle),
root_version: Some(root_version),
abandoned,
ignores_all: run.ignore_platform_reqs || run.ignore_platform_req.iter().any(|p| p == "*"),
lock_platform: !run.lock.platform.is_empty()
|| (run.with_dev && !run.lock.platform_dev.is_empty()),
}))
}
fn root_package(run: &Run<'_>, verification: &Verification) -> vivacity_core::state::RootPackage {
let rv = vivacity_core::root_version::detect(&run.manifest, &run.project);
if let Some(sender) = &verification.root_version {
let _ = sender.send(rv.clone());
}
vivacity_core::state::RootPackage::with_version(&run.manifest, rv, run.with_dev)
}
struct LocalTransaction {
arena: Vec<vivacity_resolver::package::Package>,
present: Vec<usize>,
unchanged_names: Option<Vec<String>>,
transaction: vivacity_resolver::transaction::Transaction,
missing: Vec<String>,
listeners: Vec<String>,
}
fn local_repository_transaction(
run: &Run<'_>,
root: Option<&vivacity_core::state::RootPackage>,
) -> anyhow::Result<LocalTransaction> {
let mut arena: Vec<vivacity_resolver::package::Package> = Vec::new();
let composer_dir = composer_dir_of(&run.project, &run.manifest);
let installed_raw = plugin_order::installed_json_packages(&composer_dir);
let plugins_enabled = !run.args.no_plugins;
let loaded = if plugins_enabled {
plugin_order::loaded_plugins(
&installed_raw,
&composer_dir,
plugin_order::global_composer_dir().as_deref(),
)
} else {
Vec::new()
};
let installed_raw_names = installed_raw.clone();
let installed_now = present_packages(
&run.project,
&run.manifest,
&run.lock,
run.with_dev,
plugins_enabled,
&composer_dir,
installed_raw,
);
trace("installed.json", run.t0);
let unchanged_names = unchanged_local_repository(&installed_now, &run.lock_value, run.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(
&run.lock_value,
&mut arena,
run.with_dev,
)
.map_err(|e| anyhow::anyhow!("composer.lock: {}", e.0))?;
(present, result)
};
let merged_links = run
.merged
.as_ref()
.map(|m| (m.requires.as_slice(), m.requires_dev.as_slice()));
let missing = match root {
None => Vec::new(),
Some(root) => missing_requirement_info(
&run.manifest,
&run.lock_value,
run.with_dev,
&root.version,
&root.pretty_version,
merged_links,
)?,
};
trace("local repositories", run.t0);
let transaction = vivacity_resolver::transaction::Transaction::new(&arena, &present, &result);
note_plugin_operations(run, &loaded, &installed_raw_names, &arena, &transaction);
let listeners = plugin_order::activation_order(loaded, &arena, &transaction.operations);
Ok(LocalTransaction {
arena,
present,
unchanged_names,
transaction,
missing,
listeners,
})
}
fn note_plugin_operations(
run: &Run<'_>,
loaded: &[String],
installed: &[serde_json::Value],
arena: &[vivacity_resolver::package::Package],
transaction: &vivacity_resolver::transaction::Transaction,
) {
if run.args.no_plugins {
return;
}
crate::verbose_listeners::first_load(&run.manifest, loaded, installed);
let locked: Vec<&serde_json::Value> = ["packages", "packages-dev"]
.iter()
.filter_map(|k| run.lock_value.get(*k).and_then(serde_json::Value::as_array))
.flatten()
.collect();
let target_of = |name: &str| {
locked.iter().copied().find(|p| {
p.get("name")
.and_then(serde_json::Value::as_str)
.is_some_and(|n| n.eq_ignore_ascii_case(name))
})
};
let plugin_type = |p: &vivacity_resolver::package::Package| {
matches!(
p.package_type.as_str(),
"composer-plugin" | "composer-installer"
)
};
let allowed = |name: &str| {
matches!(
vivacity_core::layout::plugin_allowed(&run.manifest, name),
vivacity_core::layout::PluginVerdict::Allowed
)
};
let mut registered: Vec<String> = loaded.iter().filter(|n| allowed(n)).cloned().collect();
use vivacity_resolver::transaction::Operation;
for op in &transaction.operations {
let (target, update) = match *op {
Operation::Install(p) => (p, false),
Operation::Update(_, t) => (t, true),
Operation::Uninstall(p) => {
registered.retain(|n| *n != arena[p].name);
continue;
}
_ => continue,
};
let name = arena[target].name.as_str();
if !plugin_type(&arena[target]) || !allowed(name) {
continue;
}
if !update && registered.iter().any(|n| n == name) {
continue;
}
if let Some(entry) = target_of(name) {
crate::verbose_listeners::plugin_registered(name, entry);
}
if !registered.iter().any(|n| n == name) {
registered.push(name.to_owned());
}
}
}
fn analyze_scope(run: &Run<'_>) -> Option<vivacity_core::scope::ScopeReport> {
let args = run.args;
let scope = if args.dry_run {
None
} else {
let mut report = vivacity_core::scope::analyze(
&run.project,
&run.lock,
&run.manifest,
run.with_dev,
!args.no_plugins,
);
if !args.after_update() {
report
.issues
.extend(vivacity_core::scope::core_project_message_issue(
&run.project,
&run.lock,
&run.manifest,
run.with_dev,
!args.no_plugins,
));
}
let installed =
plugin_order::installed_json_packages(&composer_dir_of(&run.project, &run.manifest));
let global = crate::effect_plugins::global_packages();
let ctx = vivacity_core::effect_plugins::Context {
project: &run.project,
manifest: &run.manifest,
local: run
.lock
.wanted_packages(run.with_dev)
.map(|p| &p.raw)
.collect(),
installed: &installed,
dev_mode: run.with_dev,
command: if args.after_update() {
vivacity_core::effect_plugins::Command::Update
} else {
vivacity_core::effect_plugins::Command::Install
},
interactive: !args.after_update()
&& crate::effect_plugins::interactive(args.compat.no_interaction),
no_autoloader: args.no_autoloader,
plugins_enabled: !args.no_plugins,
global: &global,
aliases: !run.lock.aliases.is_empty(),
lock_data: Some(&run.lock_value),
};
report.issues.extend(
vivacity_core::effect_plugins::issues(&ctx)
.into_iter()
.map(vivacity_core::scope::ScopeIssue::Layout),
);
Some(report)
};
trace("scope analysis", run.t0);
scope
}
fn plan_autoload_early(
run: &Run<'_>,
tx: &LocalTransaction,
scope: Option<&vivacity_core::scope::ScopeReport>,
) -> Option<anyhow::Result<PlannedDump>> {
let args = run.args;
let early_dump: Option<anyhow::Result<PlannedDump>> = if args.dry_run
|| args.no_autoloader
|| run.runner.is_some()
|| !tx.transaction.operations.is_empty()
|| crate::effect_plugins::dump_depends_on_listeners(
&run.lock,
&run.manifest,
run.with_dev,
!args.no_plugins,
) {
None
} else {
scope
.filter(|s| s.is_native_ok())
.and_then(|s| s.layout.as_ref())
.and_then(|layout| {
vivacity_core::installer::local_repository_if_unchanged(
&run.lock,
layout,
run.with_dev,
)
.map(|local| {
dump_autoload_plan(
&run.project,
&local,
&run.manifest,
layout,
run.with_dev,
args.optimize_autoloader || args.classmap_authoritative,
args.classmap_authoritative,
run.ignore_platform_reqs,
&run.ignore_platform_req,
(args.apcu_autoloader, args.apcu_autoloader_prefix.as_deref()),
!args.no_plugins,
run.lock
.packages_dev
.iter()
.map(|p| p.name().to_owned())
.collect(),
)
})
})
};
trace("autoload planned", run.t0);
early_dump
}
fn join_verification(run: &Run<'_>, verification: Verification) -> anyhow::Result<Flow> {
use vivacity_resolver::session::InstallVerdict;
let mut verification = verification;
let Some(handle) = verification.handle.take() else {
return Ok(Flow::Continue(()));
};
drop(verification.root_version.take());
let verified = match handle
.join()
.map_err(|_| anyhow::anyhow!("the lock verification thread panicked"))?
{
Ok(v) => v,
Err(e) if e.kind == vivacity_resolver::session::SessionErrorKind::Unsupported => {
let scope = vivacity_core::scope::ScopeReport {
issues: vec![vivacity_core::scope::ScopeIssue::Layout(e.message)],
skipped_plugins: vec![],
layout: None,
};
return Ok(Flow::Break(fallback_or_fail(run.args, &scope)?));
}
Err(e) => {
for line in &e.preface {
vivacity_core::say!("{line}");
}
return Err(session_error(e));
}
};
trace("lock verification", run.t0);
for w in &verified.warnings {
vivacity_core::say!("{w}");
}
if verified.php_missing && !verification.ignores_all && verification.lock_platform {
vivacity_core::say!(
"Warning: php not found, platform requirements were not checked \
(--ignore-platform-reqs silences this warning)"
);
}
say_lock_resolution(verified.resolution);
match verified.verdict {
InstallVerdict::Installable => Ok(Flow::Continue(())),
InstallVerdict::Problems(pretty) => {
let head = "Your lock file does not contain a compatible set of packages. Please run composer update.";
vivacity_core::say_always!("{head}");
vivacity_core::say!("{pretty}");
vivacity_core::io::github_action_error(&format!("{head}\n{pretty}"));
Ok(Flow::Break(2))
}
InstallVerdict::NeedsChanges => {
vivacity_core::say_always!("Your lock file cannot be installed on this system without changes. Please run composer update.");
Ok(Flow::Break(4))
}
InstallVerdict::Invalid(message) => Err(anyhow::anyhow!("{message}")),
}
}
fn report_missing(
run: &Run<'_>,
missing: &[String],
verification: &mut Verification,
) -> anyhow::Result<Flow> {
if !missing.is_empty() {
if let Some(m) = &run.merged {
let plugin_installed =
installed_packages(&run.project, &run.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()
};
verification.abandon_and_wait();
return Ok(Flow::Break(fallback_or_fail(run.args, &report)?));
}
}
for line in missing {
vivacity_core::say!("{line}");
}
if !require::truthy(require::config_value(
&run.manifest,
"allow-missing-requirements",
)) {
verification.abandon();
return Ok(Flow::Break(4));
}
}
Ok(Flow::Continue(()))
}
fn report_operations(tx: &LocalTransaction) {
use vivacity_resolver::transaction::Operation;
let ops = &tx.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 {
vivacity_core::say!("Nothing to install, update or remove");
} else {
vivacity_core::say!(
"Package 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::verbose_operation_summary(ops, &tx.arena) {
vivacity_core::say_verbose!("{line}");
}
}
}
fn dry_run(run: &Run<'_>, tx: &LocalTransaction) -> anyhow::Result<i32> {
crate::no_install::activate_yii2_composer(&run.project, &run.manifest, !run.args.no_plugins)?;
for op in &tx.transaction.operations {
if let Some(line) = op.show(&tx.arena, false) {
vivacity_core::say!(" - {line}");
}
}
report_before_dump(run)?;
print_funding(&run.project, &run.manifest);
Ok(0)
}
fn report_before_dump(run: &Run<'_>) -> anyhow::Result<()> {
let say_all = |lines: &[String]| {
for line in lines {
vivacity_core::say!("{line}");
}
};
match &run.args.post_update {
Some(report) => say_all(&report.lines),
None => {
refuse_lock_without_dev(run)?;
say_all(&abandoned_warnings(&run.lock_value));
}
}
Ok(())
}
fn native_layout(
run: &Run<'_>,
scope: Option<vivacity_core::scope::ScopeReport>,
) -> anyhow::Result<Flow<vivacity_core::layout::Layout>> {
let Some(scope) = scope else {
anyhow::bail!("internal: scope was not analysed");
};
if !scope.is_native_ok() {
return Ok(Flow::Break(fallback_or_fail(run.args, &scope)?));
}
let Some(layout) = scope.layout else {
anyhow::bail!("internal: scope is native but no layout was resolved");
};
if let Some(tag) = &layout.installers_tag {
vivacity_core::say!(
"Note: composer/installers {tag} emulated natively (custom install paths)"
);
}
for plugin in &scope.skipped_plugins {
vivacity_core::say!(
"Note: plugin {plugin} installed as a plain library (vivacity never runs plugins)"
);
}
trace("scope", run.t0);
if run.args.check_scope {
vivacity_core::say_always!("vivacity: this lock is installed natively");
return Ok(Flow::Break(0));
}
Ok(Flow::Continue(layout))
}
struct Installed {
report: vivacity_core::installer::InstallReport,
_runtime: tokio::runtime::Runtime,
}
fn execute_operations(
run: &Run<'_>,
tx: &LocalTransaction,
layout: &vivacity_core::layout::Layout,
) -> anyhow::Result<Flow<Installed>> {
let args = run.args;
let operation_lines = operation_lines(
&run.project,
&tx.arena,
&tx.transaction.operations,
layout,
run.lock
.flex_packs(&run.manifest, run.with_dev, !args.no_plugins),
!args.no_plugins,
&run.manifest,
)?;
let downloading = download_lines(
&run.lock,
&tx.arena,
&tx.transaction.operations,
run.with_dev,
);
let store = Arc::new(vivacity_core::store::Store::default_location());
let auth = vivacity_core::fetch::Auth::load(&run.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: run.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(
&run.project,
&run.lock,
&run.manifest,
layout,
store,
fetcher,
&opts,
)) {
Ok(r) => {
vivacity_core::io::release_output();
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 Ok(Flow::Break(fallback_or_fail(args, &scope)?));
}
Err(vivacity_core::Error::Refused(msg)) => {
vivacity_core::say_always!("{msg}");
return Ok(Flow::Break(1));
}
Err(e) => return Err(e.into()),
};
trace("install transaction", run.t0);
for line in &downloading {
vivacity_core::say!("{line}");
}
for line in vivacity_core::secure_http::take_redirect_warnings() {
vivacity_core::say!("{line}");
}
let c3_leaves = tx.transaction.operations.iter().any(|op| {
matches!(*op, vivacity_resolver::transaction::Operation::Uninstall(p)
if tx.arena[p].name == vivacity_core::c3_plugin::PLUGIN_NAME)
});
let c3_line = format!(" - Removing {} (", vivacity_core::c3_plugin::PLUGIN_NAME);
let mut c3_uninstalled = false;
for line in &operation_lines {
if c3_leaves && !c3_uninstalled && line.starts_with(&c3_line) {
emulate_c3_uninstall(&run.project, &run.manifest, !args.no_plugins)?;
c3_uninstalled = true;
}
vivacity_core::say!("{line}");
}
if c3_leaves && !c3_uninstalled {
emulate_c3_uninstall(&run.project, &run.manifest, !args.no_plugins)?;
}
for m in &report.messages {
vivacity_core::say!("{m}");
}
report_before_dump(run)?;
Ok(Flow::Continue(Installed {
report,
_runtime: runtime,
}))
}
fn dump_autoloader(
run: &Run<'_>,
tx: &LocalTransaction,
layout: &vivacity_core::layout::Layout,
report: &vivacity_core::installer::InstallReport,
early_dump: Option<anyhow::Result<PlannedDump>>,
) -> anyhow::Result<Flow<(String, Option<vivacity_core::vendor_cleaner::Counts>)>> {
let args = run.args;
vivacity_core::say!(
"Generating{} autoload files",
if effective_optimize(
&run.manifest,
args.optimize_autoloader,
args.classmap_authoritative
) {
" optimized"
} else {
""
}
);
if !args.no_plugins {
announce_in_order(
&tx.listeners,
crate::verbose_listeners::PRE_AUTOLOAD_DUMP,
&run.manifest,
);
}
let local = report.local_repository.as_ref().unwrap_or(&run.lock);
let packages: Vec<&vivacity_core::lock::LockPackage> =
local.wanted_packages(run.with_dev).collect();
let (root, cleaner_counts) = crate::effect_plugins::pre_autoload_dump(
&run.manifest,
layout,
local,
&packages,
run.with_dev,
!args.no_plugins,
&tx.listeners,
false,
)?;
if let Some(r) = &run.runner {
let code = r.run(scripts::PRE_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(Flow::Break(code));
}
}
let planned = match early_dump {
Some(planned) => planned?,
None => dump_autoload_plan(
&run.project,
local,
&root,
layout,
run.with_dev,
args.optimize_autoloader || args.classmap_authoritative,
args.classmap_authoritative,
run.ignore_platform_reqs,
&run.ignore_platform_req,
(args.apcu_autoloader, args.apcu_autoloader_prefix.as_deref()),
!args.no_plugins,
run.lock
.packages_dev
.iter()
.map(|p| p.name().to_owned())
.collect(),
)?,
};
let dumped = planned.finish(&run.project, &run.manifest, layout)?;
let autoload_note = format!(", autoloader with {} classes", dumped.classes);
post_autoload_dump_plugins(run, tx, local, layout)?;
if let Some(r) = &run.runner {
let code = r.run(scripts::POST_AUTOLOAD_DUMP)?;
if code != 0 {
return Ok(Flow::Break(code));
}
}
trace("autoload dump", run.t0);
Ok(Flow::Continue((autoload_note, cleaner_counts)))
}
fn local_order(tx: &LocalTransaction) -> (Vec<&str>, Vec<&str>, Vec<&str>) {
use vivacity_resolver::transaction::Operation;
let arena = &tx.arena;
let previous: Vec<&str> = match &tx.unchanged_names {
Some(names) => names.iter().map(String::as_str).collect(),
None => tx.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 &tx.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);
(order, gone, fresh)
}
fn post_autoload_dump_plugins(
run: &Run<'_>,
tx: &LocalTransaction,
local: &vivacity_core::lock::Lock,
layout: &vivacity_core::layout::Layout,
) -> anyhow::Result<()> {
let args = run.args;
let (order, gone, fresh) = local_order(tx);
let previously_present = match &tx.unchanged_names {
Some(names) => names
.iter()
.any(|n| n == vivacity_core::pest_plugin::PLUGIN_NAME),
None => tx
.present
.iter()
.any(|&i| tx.arena[i].name == vivacity_core::pest_plugin::PLUGIN_NAME),
};
emulate_pest_plugin(
&run.project,
local,
&run.manifest,
run.with_dev,
&order,
!args.no_plugins,
previously_present,
)?;
let touched: Vec<&str> = gone.iter().chain(fresh.iter()).copied().collect();
emulate_yii2_composer(
&run.project,
local,
&run.manifest,
run.with_dev,
&order,
&touched,
!args.no_plugins,
)?;
let packages: Vec<&vivacity_core::lock::LockPackage> =
local.wanted_packages(run.with_dev).collect();
crate::effect_plugins::post_autoload_dump(
&run.manifest,
layout,
local,
&packages,
run.with_dev,
!args.no_plugins,
)?;
let drupol = crate::effect_plugins::drupol_run(
Some(&run.lock_value),
local,
&run.manifest,
run.with_dev,
!args.no_plugins,
);
post_autoload_dump_printers(
&run.project,
local,
&run.manifest,
run.with_dev,
!args.no_plugins,
&tx.listeners,
drupol.as_ref(),
)
}
pub(crate) fn post_autoload_dump_printers(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
listeners: &[String],
drupol: Option<&crate::effect_plugins::DrupolRun<'_>>,
) -> anyhow::Result<()> {
let mut emulated = vec![
vivacity_core::bamarni_bin::PLUGIN_NAME,
vivacity_core::package_versions::PLUGIN_NAME,
vivacity_core::effect_plugins::DRUPOL,
];
let event = crate::verbose_listeners::POST_AUTOLOAD_DUMP;
for name in crate::verbose_listeners::listening_to(event) {
if !emulated.contains(&name) {
emulated.push(name);
}
}
for plugin in plugin_order::listeners_in_order(listeners, &emulated) {
let loaded = plugins_enabled && listeners.iter().any(|n| n == plugin);
if loaded {
crate::verbose_listeners::announce(plugin, event, manifest);
}
if plugin == vivacity_core::bamarni_bin::PLUGIN_NAME {
if loaded {
emulate_bamarni_bin(manifest);
}
} else if plugin == vivacity_core::package_versions::PLUGIN_NAME {
emulate_package_versions(project, local, manifest, with_dev, plugins_enabled)?;
} else if plugin == vivacity_core::effect_plugins::DRUPOL {
if let Some(run) = drupol {
crate::effect_plugins::composer_packages(project, manifest, run)?;
}
}
}
Ok(())
}
pub(crate) fn announce_in_order(listeners: &[String], event: &str, manifest: &serde_json::Value) {
let names = crate::verbose_listeners::listening_to(event);
for plugin in listeners {
if names.contains(&plugin.as_str()) {
crate::verbose_listeners::announce(plugin, event, manifest);
}
}
}
fn post_install(
run: &Run<'_>,
layout: &vivacity_core::layout::Layout,
report: &vivacity_core::installer::InstallReport,
tx: &LocalTransaction,
cleaner_counts: Option<&vivacity_core::vendor_cleaner::Counts>,
) -> anyhow::Result<Flow> {
let args = run.args;
let listeners = &tx.listeners;
let (order, _, _) = local_order(tx);
print_funding(&run.project, &run.manifest);
let local = report.local_repository.as_ref().unwrap_or(&run.lock);
if !args.no_plugins {
crate::effect_plugins::skeleton(&run.project, &run.manifest, local, run.with_dev, true)?;
let mut emulated = vec![
vivacity_core::phpcs_installer::PLUGIN_NAME,
extension_installers::PHPSTAN,
extension_installers::RECTOR,
extension_installers::INFECTION,
vivacity_core::c3_plugin::PLUGIN_NAME,
"symfony/flex",
vivacity_core::effect_plugins::DG_CLEANER,
vivacity_core::effect_plugins::VENDOR_CLEANER,
vivacity_core::effect_plugins::PATCHER,
];
let event = if args.after_update() {
crate::verbose_listeners::POST_UPDATE_CMD
} else {
crate::verbose_listeners::POST_INSTALL_CMD
};
for name in crate::verbose_listeners::listening_to(event) {
if !emulated.contains(&name) {
emulated.push(name);
}
}
for plugin in plugin_order::listeners_in_order(listeners, &emulated) {
if listeners.iter().any(|n| n == plugin) {
crate::verbose_listeners::announce(plugin, event, &run.manifest);
}
post_install_listener(run, layout, local, &order, plugin, cleaner_counts)?;
}
}
if let Some(r) = &run.runner {
let code = r.run(scripts::POST_INSTALL_CMD)?;
if code != 0 {
return Ok(Flow::Break(code));
}
}
Ok(Flow::Continue(()))
}
fn post_install_listener(
run: &Run<'_>,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
order: &[&str],
plugin: &str,
cleaner_counts: Option<&vivacity_core::vendor_cleaner::Counts>,
) -> anyhow::Result<()> {
let args = run.args;
match plugin {
vivacity_core::effect_plugins::DG_CLEANER => crate::effect_plugins::composer_cleaner(
&run.manifest,
layout,
local,
run.with_dev,
!args.no_plugins,
)?,
vivacity_core::effect_plugins::VENDOR_CLEANER => {
crate::effect_plugins::vendor_cleaner_finish(
&run.manifest,
layout,
local,
run.with_dev,
!args.no_plugins,
cleaner_counts,
)?
}
vivacity_core::phpcs_installer::PLUGIN_NAME => {
emulate_phpcs(&run.project, layout, local, &run.manifest, run.with_dev)?;
}
extension_installers::PHPSTAN => extension_installers::phpstan(
layout,
local,
&run.lock.aliases,
&run.manifest,
run.with_dev,
!args.no_plugins,
)?,
extension_installers::RECTOR => extension_installers::rector(
layout,
local,
&run.manifest,
run.with_dev,
!args.no_plugins,
)?,
extension_installers::INFECTION => extension_installers::infection(
layout,
local,
order,
&run.manifest,
run.with_dev,
!args.no_plugins,
)?,
vivacity_core::effect_plugins::PATCHER => {
if let Some(patched) = crate::effect_plugins::patcher_post(
&run.project,
&run.manifest,
layout,
local,
order,
run.with_dev,
!args.no_plugins,
)? {
let root = vivacity_core::state::RootPackage::detect(
&run.manifest,
&run.project,
run.with_dev,
);
vivacity_core::state::write_state_files(
&layout.composer_dir(),
&patched,
&root,
&run.manifest,
run.with_dev,
layout,
)?;
}
}
vivacity_core::c3_plugin::PLUGIN_NAME => emulate_c3(
&run.project,
local,
&run.manifest,
run.with_dev,
args.after_update(),
!args.no_plugins,
)?,
"symfony/flex" => match &args.post_update {
None => emulate_flex_install(&run.project, &run.manifest, !args.no_plugins)?,
Some(update) if update.flex_active => {
print_flex_post_update(
&update.manifest,
update.thanks_reminder,
update.flex_plan.as_deref(),
)?;
}
Some(_) => {}
},
_ => {}
}
Ok(())
}
pub(crate) fn emulate_phpcs(
project: &std::path::Path,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
) -> anyhow::Result<()> {
use vivacity_core::phpcs_installer as phpcs;
let installed: Vec<&vivacity_core::lock::LockPackage> =
local.wanted_packages(with_dev).collect();
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, phpcs::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if let Some(own) = installed
.iter()
.find(|p| p.name() == phpcs::PLUGIN_NAME)
.filter(|_| allowed)
{
let change = phpcs::register_standards(
project,
layout,
&installed,
manifest,
phpcs::variant(own.version()),
)?;
if let Some(line) = change.line() {
vivacity_core::out!("{line}");
}
}
Ok(())
}
fn say_summary(
run: &Run<'_>,
report: &vivacity_core::installer::InstallReport,
autoload_note: &str,
) {
let warmed = if report.store_warmed > 0 {
format!(", store warmed for {} packages", report.store_warmed)
} else {
String::new()
};
let git = if report.from_git > 0 {
format!(", {} from git", report.from_git)
} else {
String::new()
};
vivacity_core::say!(
"vivacity: {} installed, {} unchanged, {} removed ({} from store, {} from cache, {} from network{git}){warmed}{autoload_note} in {:.2}s",
report.installed,
report.unchanged,
report.removed,
report.store_hits,
report.from_cache,
report.from_network,
run.t0.elapsed().as_secs_f32()
);
}
pub(crate) 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(())
}
pub(crate) 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(())
}
pub(crate) fn emulate_c3_uninstall(
project: &std::path::Path,
manifest: &serde_json::Value,
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_core::c3_plugin as c3;
let allowed = matches!(
vivacity_core::layout::plugin_allowed(manifest, c3::PLUGIN_NAME),
vivacity_core::layout::PluginVerdict::Allowed
);
if plugins_enabled && allowed && c3::delete_c3(project)? {
vivacity_core::out!("[codeception/c3] Deleting c3.php from the root of your project...");
}
Ok(())
}
pub(crate) fn emulate_c3(
project: &std::path::Path,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: 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 || !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 => {
vivacity_core::out!("[codeception/c3] c3.php is already up-to-date");
}
c3::C3Action::Copied => {
vivacity_core::out!("[codeception/c3] Copying c3.php to the root of your project...");
vivacity_core::out!("[codeception/c3] Include c3.php into index.php in order to collect codecoverage from server scripts");
}
_ => {}
}
Ok(())
}
pub(crate) fn emulate_bamarni_bin(manifest: &serde_json::Value) {
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 !allowed {
return;
}
vivacity_core::say_verbose!("[bamarni-bin] Calling onPostAutoloadDump().");
if let Ok(cfg) = bin::config(manifest.get("extra")) {
bin::print_deprecations(&cfg);
}
}
pub(crate) 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);
if !pv::versions_dir(&vendor).exists() {
vivacity_core::out!("composer/package-versions-deprecated: Package not found (probably scheduled for removal); generation of version class skipped.");
return Ok(());
}
vivacity_core::out!("composer/package-versions-deprecated: Generating version class...");
pv::write(&vendor, &pv::render(&root.name, &versions))?;
vivacity_core::out!("composer/package-versions-deprecated: ...done generating version class");
Ok(())
}
pub(crate) fn insecure_dist_reason(
project: &std::path::Path,
manifest: &serde_json::Value,
lock: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
) -> Option<String> {
use serde_json::Value;
use vivacity_core::secure_http::{classify, Verdict};
let mut installed: Option<Vec<Value>> = None;
for p in lock.wanted_packages(with_dev) {
if p.is_metapackage() || p.dist_kind() == vivacity_core::lock::DistKind::Missing {
continue;
}
let dist = p.raw.get("dist");
let any = dist
.and_then(|d| d.get("url"))
.and_then(Value::as_str)
.into_iter()
.chain(
dist.and_then(|d| d.get("mirrors"))
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|m| m.get("url").and_then(Value::as_str)),
)
.any(|u| vivacity_core::secure_http::insecure(u).is_some());
if !any {
continue;
}
let first_mirror = first_preferred_mirror(dist);
let mut why = None;
for url in first_mirror.into_iter().chain(p.dist_url_expanded()) {
why = match classify(&url) {
Verdict::Refuse => Some("which secure-http refuses".to_owned()),
Verdict::HandOver(reason) => Some(format!("with {reason}")),
Verdict::Allowed | Verdict::Warn { .. } => continue,
};
break;
}
let Some(why) = why else { continue };
let present = installed.get_or_insert_with(|| {
let composer_dir = composer_dir_of(project, manifest);
present_packages(
project,
manifest,
lock,
with_dev,
plugins_enabled,
&composer_dir,
plugin_order::installed_json_packages(&composer_dir),
)
});
if installed_as_locked(present, p) {
continue;
}
return Some(format!(
"the dist of {} is downloaded over an insecure protocol, {why}",
p.name()
));
}
None
}
fn first_preferred_mirror(dist: Option<&serde_json::Value>) -> Option<String> {
use serde_json::Value;
let main = dist.and_then(|d| d.get("url")).and_then(Value::as_str)?;
let mut urls: std::collections::VecDeque<&str> = std::collections::VecDeque::from([main]);
for m in dist
.and_then(|d| d.get("mirrors"))
.and_then(Value::as_array)
.into_iter()
.flatten()
{
let Some(url) = m.get("url").and_then(Value::as_str) else {
continue;
};
if urls.contains(&url) {
continue;
}
if m.get("preferred").is_some_and(crate::manifest::php_truthy) {
urls.push_front(url);
} else {
urls.push_back(url);
}
}
let first = *urls.front()?;
(first != main).then(|| first.to_owned())
}
pub(crate) fn any_insecure_dist(lock: &serde_json::Value) -> bool {
use serde_json::Value;
["packages", "packages-dev"]
.iter()
.filter_map(|k| lock.get(*k).and_then(Value::as_array))
.flatten()
.filter_map(|p| p.get("dist"))
.any(|d| {
let main = d.get("url").and_then(Value::as_str);
let mirrors = d
.get("mirrors")
.and_then(Value::as_array)
.into_iter()
.flatten()
.filter_map(|m| m.get("url").and_then(Value::as_str));
main.into_iter()
.chain(mirrors)
.any(|u| vivacity_core::secure_http::insecure(u).is_some())
})
}
fn max_parallel_http() -> usize {
let Ok(raw) = std::env::var("COMPOSER_MAX_PARALLEL_HTTP") else {
return 12;
};
let trimmed = raw.trim_matches([' ', '\t', '\n', '\r', '\x0b', '\x0c']);
let numeric = !trimmed.is_empty()
&& trimmed
.chars()
.all(|c| c.is_ascii_digit() || matches!(c, '.' | 'e' | 'E' | '+' | '-'))
&& trimmed.parse::<f64>().is_ok_and(f64::is_finite);
if !numeric {
return 12;
}
let n = trimmed.parse::<f64>().unwrap_or(12.0).trunc();
n.clamp(1.0, 50.0) as usize
}
pub(crate) 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();
let max_jobs = max_parallel_http();
let mut started = 0usize;
let mut queued: Vec<(String, String)> = 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;
};
if locked.is_metapackage() {
continue;
}
if locked.dist_kind() == vivacity_core::lock::DistKind::Missing {
if let Some(source) = package
.source
.as_ref()
.filter(|s| s.kind == "git" && package.package_type != "metapackage")
{
if !vivacity_core::git_source::is_local_path(&source.url) {
lines.push(vivacity_core::git_source::syncing_line(
&package.name,
&vivacity_resolver::transaction::full_pretty_version(
package,
true,
DisplayRef::SourceRefIfDev,
),
));
}
}
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
)
));
let requested =
first_preferred_mirror(locked.raw.get("dist")).unwrap_or_else(|| url.clone());
if let vivacity_core::secure_http::Verdict::Warn { scheme, host } =
vivacity_core::secure_http::classify(&requested)
{
if started < max_jobs {
lines.extend(vivacity_core::secure_http::warn_once(&scheme, &host));
} else {
queued.push((scheme, host));
}
}
let scheme = requested.split("://").next().unwrap_or("");
if scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https") {
started += 1;
}
}
for (scheme, host) in queued {
lines.extend(vivacity_core::secure_http::warn_once(&scheme, &host));
}
lines
}
pub(crate) 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,
manifest: &serde_json::Value,
) -> anyhow::Result<Vec<String>> {
use vivacity_resolver::transaction::Operation;
let mut lines = Vec::new();
let installers_loaded = !plugins_enabled
|| crate::plugin_allow::load_for(project, manifest)
.loaded
.iter()
.any(|n| n == "composer/installers")
|| vivacity_core::layout::plugin_allowed(manifest, "composer/installers")
!= vivacity_core::layout::PluginVerdict::Allowed;
let mut deprecation_due = !installers_loaded;
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()),
}
}
None if pkg.package_type != "metapackage"
&& pkg.source.as_ref().is_some_and(|s| s.kind == "git") =>
{
let source = pkg.source.as_ref();
let url = source.map(|s| s.url.as_str()).unwrap_or("");
let reference = source.and_then(|s| s.reference.as_deref()).unwrap_or("");
vivacity_core::git_source::install_appendix(
reference,
!vivacity_core::git_source::is_local_path(url),
vivacity_core::io::level() == vivacity_core::io::Verbosity::Verbose,
)
}
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 let Operation::Install(p) | Operation::Update(_, p) = *op {
let pkg = &arena[p];
if deprecation_due && pkg.name == "composer/installers" {
let notes =
crate::plugin_allow::installers_deprecation(&layout.vendor_dir(), &pkg.version);
deprecation_due = notes.is_empty();
lines.extend(notes);
}
}
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)
}
pub(crate) 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)
})
}
pub(crate) 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(),
)
}
pub(crate) 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)
}
pub(crate) fn installed_packages(
project: &std::path::Path,
manifest: &serde_json::Value,
) -> Vec<serde_json::Value> {
let composer_dir = composer_dir_of(project, manifest);
purge_missing(
&composer_dir,
plugin_order::installed_json_packages(&composer_dir),
)
}
pub(crate) fn present_packages(
project: &std::path::Path,
manifest: &serde_json::Value,
lock: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
composer_dir: &std::path::Path,
installed_raw: Vec<serde_json::Value>,
) -> Vec<serde_json::Value> {
let mut installed_now = purge_missing(composer_dir, installed_raw);
if let Ok(layout) =
vivacity_core::layout::Layout::resolve(project, lock, manifest, with_dev, plugins_enabled)
{
installed_now.retain(|p| {
let name = p
.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or_default();
if p.get("type").and_then(serde_json::Value::as_str) == Some("metapackage")
|| layout.install_path(name).is_none()
{
return true;
}
layout.abs(name).is_none_or(|d| d.exists())
});
}
if !vivacity_core::scope::active_plugins(project, manifest, plugins_enabled)
.iter()
.any(|p| p == "symfony/flex")
{
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.unwrap_or_default()
.vendor_dir(project);
installed_now.retain(|p| {
let pack = p.get("type").and_then(serde_json::Value::as_str) == Some("symfony-pack");
let no_path = p.get("install-path").is_none_or(serde_json::Value::is_null);
let name = p
.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or_default();
!(pack && no_path && !vendor.join(name).exists())
});
}
installed_now
}
pub(crate) fn purge_missing(
composer_dir: &std::path::Path,
list: Vec<serde_json::Value>,
) -> Vec<serde_json::Value> {
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()
}
pub(crate) fn print_funding(project: &std::path::Path, manifest: &serde_json::Value) {
if !funding_shown(std::env::var("COMPOSER_FUND").ok().as_deref()) {
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 {
vivacity_core::say!(
"{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 funding_shown(env: Option<&str>) -> bool {
let Some(t) = env.map(str::trim) else {
return true;
};
let lower = t.to_ascii_lowercase();
if lower.contains("inf") || lower.contains("nan") {
return true;
}
match t.parse::<f64>() {
Ok(n) => n.is_finite() && n.trunc() != 0.0,
Err(_) => true,
}
}
pub(crate) 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
}
#[cfg(test)]
mod funding_tests {
use super::funding_shown;
#[test]
fn funding_hidden_by_a_numeric_fund_that_truncates_to_zero() {
assert!(funding_shown(None));
assert!(funding_shown(Some("")));
assert!(funding_shown(Some("no")));
assert!(funding_shown(Some("1")));
assert!(funding_shown(Some(" 2.5 ")));
assert!(!funding_shown(Some("0")));
assert!(!funding_shown(Some("0.5")));
assert!(!funding_shown(Some("-0.9")));
assert!(!funding_shown(Some("1e400")));
assert!(funding_shown(Some("inf")));
assert!(funding_shown(Some("NaN")));
}
}
#[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()
);
}
}