use std::io::IsTerminal as _;
use vivacity_core::effect_plugins as fx;
pub(crate) fn interactive(no_interaction: bool) -> bool {
let env_true = |k: &str| {
std::env::var(k)
.ok()
.is_some_and(|v| !v.is_empty() && v != "0")
};
!no_interaction
&& !env_true("COMPOSER_NO_INTERACTION")
&& vivacity_core::io::level() != vivacity_core::io::Verbosity::Quiet
&& std::env::var("SHELL_VERBOSITY").ok().as_deref() != Some("-1")
&& std::io::stdin().is_terminal()
}
pub(crate) fn global_packages() -> Vec<serde_json::Value> {
crate::plugin_order::global_composer_dir()
.map(|d| crate::plugin_order::installed_json_packages(&d))
.unwrap_or_default()
}
fn allowed(manifest: &serde_json::Value, name: &str) -> bool {
matches!(
vivacity_core::layout::plugin_allowed(manifest, name),
vivacity_core::layout::PluginVerdict::Allowed
)
}
pub(crate) fn active(
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
plugin: &str,
) -> bool {
plugins_enabled
&& allowed(manifest, plugin)
&& local.wanted_packages(with_dev).any(|p| p.name() == plugin)
}
pub(crate) fn vendor_cleaner(
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
dev_mode: bool,
plugins_enabled: bool,
) -> Option<vivacity_core::vendor_cleaner::Config> {
if !active(
local,
manifest,
dev_mode,
plugins_enabled,
fx::VENDOR_CLEANER,
) {
return None;
}
vivacity_core::vendor_cleaner::Config::read(manifest)
.ok()
.flatten()
.filter(|c| !(c.no_dev_only && dev_mode))
}
pub(crate) fn dump_depends_on_listeners(
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
dev_mode: bool,
plugins_enabled: bool,
) -> bool {
vendor_cleaner(local, manifest, dev_mode, plugins_enabled).is_some()
|| active(local, manifest, dev_mode, plugins_enabled, fx::CAKEPHP)
|| active(
local,
manifest,
dev_mode,
plugins_enabled,
fx::CLASS_ALIAS_LOADER,
)
}
fn packages_with_paths(
packages: &[&vivacity_core::lock::LockPackage],
layout: &vivacity_core::layout::Layout,
) -> Vec<(String, Option<std::path::PathBuf>)> {
packages
.iter()
.map(|p| (p.name().to_owned(), layout.abs(p.name())))
.collect()
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn pre_autoload_dump(
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
packages: &[&vivacity_core::lock::LockPackage],
dev_mode: bool,
plugins_enabled: bool,
listeners: &[String],
whole_run: bool,
) -> anyhow::Result<(
serde_json::Value,
Option<vivacity_core::vendor_cleaner::Counts>,
)> {
let mut root = manifest.clone();
let mut counts = None;
let cleaner = vendor_cleaner(local, manifest, dev_mode, plugins_enabled);
let order = crate::plugin_order::listeners_in_order(
listeners,
&[fx::VENDOR_CLEANER, fx::CAKEPHP, fx::CLASS_ALIAS_LOADER],
);
for plugin in order {
if plugin == fx::VENDOR_CLEANER {
let Some(config) = cleaner.as_ref() else {
continue;
};
vivacity_core::out!();
vivacity_core::out!("Composer vendor cleaner: Cleaning packages in vendor directory");
let mut c = vivacity_core::vendor_cleaner::Cleaner::new(config);
c.cleanup_packages(&packages_with_paths(packages, layout))?;
if whole_run {
finish_vendor_cleaner(&mut c, layout)?;
}
counts = Some(c.counts);
} else if plugin == fx::CAKEPHP
&& active(local, manifest, dev_mode, plugins_enabled, fx::CAKEPHP)
{
let paths = vivacity_core::cakephp_plugins::plugin_paths(manifest)
.map_err(|e| anyhow::anyhow!("{e}"))?;
let real = vivacity_core::cakephp_plugins::real_vendor(&layout.vendor_dir())?;
root = vivacity_core::cakephp_plugins::root_with_app_plugins(&root, &real, &paths)?;
} else if plugin == fx::CLASS_ALIAS_LOADER
&& active(
local,
manifest,
dev_mode,
plugins_enabled,
fx::CLASS_ALIAS_LOADER,
)
{
root = class_alias_loader(manifest, &root, layout)?;
}
}
Ok((root, counts))
}
fn class_alias_loader(
manifest: &serde_json::Value,
root: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
) -> anyhow::Result<serde_json::Value> {
use vivacity_core::class_alias_loader as cal;
if !cal::always_add(manifest) {
return Ok(root.clone());
}
let vendor = layout.vendor_dir();
let configured = cal::configured_suffix(manifest).map_err(|e| anyhow::anyhow!("{e}"))?;
let existing = std::fs::read(vendor.join("autoload.php"))
.ok()
.map(|b| String::from_utf8_lossy(&b).into_owned());
let suffix = cal::pick_suffix(configured, existing.as_deref(), cal::random_suffix);
cal::write_files(&vendor, &suffix, manifest)?;
vivacity_core::out!("Generating empty class alias map file");
cal::root_with_include(root, "vendor").map_err(|e| anyhow::anyhow!("{e}"))
}
fn finish_vendor_cleaner(
c: &mut vivacity_core::vendor_cleaner::Cleaner<'_>,
layout: &vivacity_core::layout::Layout,
) -> anyhow::Result<()> {
if c.cleanup_binary(&layout.bin_dir())? {
vivacity_core::out!("Composer vendor cleaner: Cleaning vendor binary directory");
}
vivacity_core::out!("{}", c.summary());
vivacity_core::out!();
Ok(())
}
pub(crate) fn post_autoload_dump(
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
packages: &[&vivacity_core::lock::LockPackage],
dev_mode: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
if !active(local, manifest, dev_mode, plugins_enabled, fx::CAKEPHP) {
return Ok(());
}
let paths = vivacity_core::cakephp_plugins::plugin_paths(manifest)
.map_err(|e| anyhow::anyhow!("{e}"))?;
let vendor = layout.vendor_dir();
let real = vivacity_core::cakephp_plugins::real_vendor(&vendor)?;
let raws: Vec<&serde_json::Map<String, serde_json::Value>> =
packages.iter().map(|p| &p.raw).collect();
let contents = vivacity_core::cakephp_plugins::config_file(&raws, &real, &paths)
.map_err(|e| anyhow::anyhow!("{e}"))?;
vivacity_core::cakephp_plugins::write_config_file(&vendor, &contents)?;
Ok(())
}
pub(crate) fn skeleton(
project: &std::path::Path,
manifest: &serde_json::Value,
local: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
if !active(
local,
manifest,
with_dev,
plugins_enabled,
fx::LAMINAS_SKELETON,
) || fx::laminas_skeleton_configured(manifest) != Ok(true)
{
return Ok(());
}
for line in fx::SKELETON_LINES {
vivacity_core::out!("{line}");
}
let file = vivacity_resolver::config_source::composer_file(project);
fx::laminas_skeleton_rewrite(&file)?;
Ok(())
}
pub(crate) fn composer_cleaner(
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
if !active(local, manifest, with_dev, plugins_enabled, fx::DG_CLEANER) {
return Ok(());
}
let ignore = vivacity_core::composer_cleaner::ignore_paths(manifest)
.map_err(|e| anyhow::anyhow!("{e}"))?;
let cleaned = vivacity_core::composer_cleaner::clean(&layout.vendor_dir(), &ignore)?;
for e in &cleaned.errors {
vivacity_core::say!("{e}");
}
vivacity_core::out!(
"Composer cleaner: Removed {} files or directories.",
cleaned.removed
);
Ok(())
}
pub(crate) fn vendor_cleaner_finish(
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
counts: Option<&vivacity_core::vendor_cleaner::Counts>,
) -> anyhow::Result<()> {
let (Some(config), Some(counts)) = (
vendor_cleaner(local, manifest, with_dev, plugins_enabled),
counts,
) else {
return Ok(());
};
let mut c = vivacity_core::vendor_cleaner::Cleaner::new(&config);
c.counts = counts.clone();
finish_vendor_cleaner(&mut c, layout)
}
const REPLAYED: &[(&str, &[&str])] = &[
(fx::DRUPOL, &[crate::scripts::POST_AUTOLOAD_DUMP]),
(
crate::extension_installers::INFECTION,
&[crate::scripts::POST_INSTALL_CMD],
),
(
crate::extension_installers::PHPSTAN,
&[crate::scripts::POST_INSTALL_CMD],
),
(fx::CLASS_ALIAS_LOADER, &[crate::scripts::PRE_AUTOLOAD_DUMP]),
(
fx::PATCHER,
&[
crate::scripts::PRE_INSTALL_CMD,
crate::scripts::POST_INSTALL_CMD,
],
),
];
pub(crate) fn replay_issue(
manifest: &serde_json::Value,
local: &vivacity_core::lock::Lock,
with_dev: bool,
plugins_enabled: bool,
run_scripts: bool,
commands_events: &[&str],
) -> Option<String> {
if !run_scripts {
return None;
}
let declared = crate::scripts::declared_events(manifest);
REPLAYED.iter().find_map(|(plugin, events)| {
let event = events
.iter()
.find(|e| declared.contains(**e) && commands_events.contains(e))?;
active(local, manifest, with_dev, plugins_enabled, plugin).then(|| {
format!("plugin {plugin} would run again through `composer run-script {event}` (not emulated)")
})
})
}
pub(crate) struct DrupolRun<'a> {
lock: &'a serde_json::Value,
flex_packs: bool,
}
pub(crate) fn drupol_run<'a>(
lock_data: Option<&'a serde_json::Value>,
local: &vivacity_core::lock::Lock,
manifest: &serde_json::Value,
with_dev: bool,
plugins_enabled: bool,
) -> Option<DrupolRun<'a>> {
if !active(local, manifest, with_dev, plugins_enabled, fx::DRUPOL) {
return None;
}
Some(DrupolRun {
lock: lock_data?,
flex_packs: local.flex_packs(manifest, with_dev, plugins_enabled),
})
}
pub(crate) fn composer_packages(
project: &std::path::Path,
manifest: &serde_json::Value,
run: &DrupolRun<'_>,
) -> anyhow::Result<()> {
use vivacity_core::composer_packages as cp;
vivacity_core::out!("drupol/composer-packages: Regenerating classes...");
let root_name = manifest
.get("name")
.and_then(serde_json::Value::as_str)
.map_or_else(|| "__root__".to_owned(), str::to_ascii_lowercase);
let base = vivacity_core::pathutil::canonicalize(project)?;
let vendor = vivacity_core::dirs::Dirs::resolve(manifest)
.map_err(|e| anyhow::anyhow!("{e}"))?
.vendor_dir(&base);
let vendor_real = cp::php_realpath(&vendor)?;
let vendor_real = vendor_real
.to_str()
.ok_or_else(|| anyhow::anyhow!("{}: not UTF-8", vendor_real.display()))?;
let generated_at = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.unwrap_or_default();
let classes = cp::render(
run.lock,
&cp::Input {
root_name: &root_name,
vendor_real,
flex_packs: run.flex_packs,
generated_at,
},
)?;
cp::write(
&vendor
.join("drupol")
.join("composer-packages")
.join("build"),
&classes,
)?;
vivacity_core::out!("drupol/composer-packages: Done.");
Ok(())
}
fn path_with_bin_dir(bin: &std::path::Path) -> Option<std::ffi::OsString> {
if !bin.is_dir() {
return None;
}
let real = std::fs::canonicalize(bin).ok()?;
let path = std::env::var_os("PATH").unwrap_or_default();
if std::env::split_paths(&path).any(|p| p == real) {
return None;
}
std::env::join_paths(std::iter::once(real).chain(std::env::split_paths(&path))).ok()
}
fn patcher_root(
project: &std::path::Path,
manifest: &serde_json::Value,
with_dev: bool,
) -> serde_json::Map<String, serde_json::Value> {
let root = vivacity_core::state::RootPackage::detect(manifest, project, with_dev);
vivacity_core::composer_patcher::root_entry(manifest, &root)
}
fn package_name(p: &serde_json::Map<String, serde_json::Value>) -> &str {
p.get("name")
.and_then(serde_json::Value::as_str)
.unwrap_or_default()
}
pub(crate) fn patcher_pre(
project: &std::path::Path,
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
with_dev: bool,
plugins_enabled: bool,
) -> anyhow::Result<()> {
use vivacity_core::composer_patcher as cp;
if !plugins_enabled || !allowed(manifest, fx::PATCHER) {
return Ok(());
}
let installed = crate::plugin_order::installed_json_packages(
&crate::manifest::composer_dir_of(project, manifest),
);
let vendor = layout.vendor_dir();
let mut entries = fx::present_installed(&installed, &vendor);
if !entries.iter().any(|p| package_name(p) == fx::PATCHER) {
return Ok(());
}
entries.sort_by(|a, b| package_name(a).cmp(package_name(b)));
let sources: Vec<cp::Source<'_>> = entries
.iter()
.map(|p| cp::Source {
package: p,
dir: vendor.join(package_name(p)),
})
.collect();
let root = patcher_root(project, manifest, with_dev);
let root_source = cp::Source {
package: &root,
dir: project.to_path_buf(),
};
let collection =
cp::collect(manifest, &root_source, &sources).map_err(|e| anyhow::anyhow!("{e}"))?;
for line in &collection.lines {
vivacity_core::out!("{line}");
}
Ok(())
}
pub(crate) fn patcher_post(
project: &std::path::Path,
manifest: &serde_json::Value,
layout: &vivacity_core::layout::Layout,
local: &vivacity_core::lock::Lock,
order: &[&str],
with_dev: bool,
plugins_enabled: bool,
) -> anyhow::Result<Option<vivacity_core::lock::Lock>> {
use vivacity_core::composer_patcher as cp;
if !active(local, manifest, with_dev, plugins_enabled, fx::PATCHER) {
return Ok(None);
}
let packages =
crate::extension_installers::in_order(local.wanted_packages(with_dev).collect(), order);
let sources: Vec<cp::Source<'_>> = packages
.iter()
.map(|p| cp::Source {
package: &p.raw,
dir: layout
.abs(p.name())
.unwrap_or_else(|| layout.vendor_dir().join(p.name())),
})
.collect();
let root = patcher_root(project, manifest, with_dev);
let root_source = cp::Source {
package: &root,
dir: project.to_path_buf(),
};
let collection =
cp::collect(manifest, &root_source, &sources).map_err(|e| anyhow::anyhow!("{e}"))?;
for line in &collection.lines {
vivacity_core::out!("{line}");
}
if collection.patches.is_empty() {
vivacity_core::out!("No patches supplied.");
return Ok(None);
}
let mut patcher = cp::Patcher::new(path_with_bin_dir(&layout.bin_dir()));
let mut records: Vec<(String, serde_json::Value)> = Vec::new();
for p in &packages {
let patches = collection.for_package(&p.name().to_ascii_lowercase(), p.version());
if patches.is_empty() {
continue;
}
let Some(dir) = layout.abs(p.name()) else {
continue;
};
cp::detach(&dir)?;
let mut all_passed = true;
for patch in &patches {
let outcome = patcher.apply(patch, &dir)?;
vivacity_core::out!(
"Applying patch {}/{} to {}... {}",
patch.from_name,
patch.description,
p.name().to_ascii_lowercase(),
outcome.text()
);
if matches!(outcome, cp::Outcome::Failed(_)) {
all_passed = false;
}
}
if all_passed {
if let Some(record) = cp::applied_record(&patches) {
records.push((p.name().to_owned(), record));
}
}
}
if records.is_empty() {
return Ok(None);
}
let mut patched = local.clone();
for p in patched
.packages
.iter_mut()
.chain(patched.packages_dev.iter_mut())
{
if let Some((_, record)) = records.iter().find(|(n, _)| n == p.name()) {
cp::set_applied(&mut p.raw, record.clone());
}
}
Ok(Some(patched))
}