use super::*;
pub(crate) 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)
}
pub(crate) fn effective_optimize(
manifest: &serde_json::Value,
optimize: bool,
authoritative: bool,
) -> bool {
optimize
|| authoritative
|| config_bool(manifest, "classmap-authoritative")
|| config_bool(manifest, "optimize-autoloader")
}
pub(crate) 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)
}
pub(crate) 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))
}
pub(crate) 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(())
}
pub(crate) 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)
}
pub(crate) 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(())
}
pub(crate) fn hold_root_version_warning(project: &std::path::Path) -> Option<String> {
if !vivacity_core::io::shows(vivacity_core::io::Verbosity::Normal)
|| refuse_alternate_manifest().is_err()
{
return None;
}
let text = std::fs::read_to_string(project.join("composer.json")).ok()?;
let manifest: serde_json::Value = serde_json::from_str(&text).ok()?;
let line = vivacity_resolver::root::undetected_version_warning(&manifest, project)?;
vivacity_core::io::hold(vivacity_core::io::Verbosity::Normal, line.clone());
Some(line)
}
pub(crate) fn env_no_dev() -> bool {
std::env::var("COMPOSER_NO_DEV").is_ok_and(|v| !v.is_empty() && v != "0")
}
pub(crate) fn platform_requirement_env(
all: bool,
list: &[String],
warn: bool,
) -> (bool, Vec<String>) {
let mut all = all;
let mut list = list.to_vec();
let hold = |line: String| {
if warn {
vivacity_core::io::hold(vivacity_core::io::Verbosity::Normal, line);
}
};
if !all
&& std::env::var("COMPOSER_IGNORE_PLATFORM_REQS").is_ok_and(|v| !v.is_empty() && v != "0")
{
all = true;
hold(
"COMPOSER_IGNORE_PLATFORM_REQS is set. You may experience unexpected errors."
.to_owned(),
);
}
if !all && list.is_empty() {
if let Ok(env) = std::env::var("COMPOSER_IGNORE_PLATFORM_REQ") {
if !env.is_empty() {
hold(format!(
"COMPOSER_IGNORE_PLATFORM_REQ is set to ignore {env}. You may experience unexpected errors."
));
list = env.split(',').map(str::to_owned).collect();
}
}
}
(all, list)
}
pub(crate) fn hold_ignored_lock_warning(project: &std::path::Path) -> Option<String> {
let text = std::fs::read_to_string(project.join("composer.json")).ok()?;
let manifest: serde_json::Value = serde_json::from_str(&text).ok()?;
if config_lock_enabled(&text)
|| !project.join("composer.lock").exists()
|| vivacity_resolver::root::manifest_error(&manifest).is_some()
{
return None;
}
let line = "./composer.lock is present but ignored as the \"lock\" config option is disabled."
.to_owned();
vivacity_core::io::hold(vivacity_core::io::Verbosity::Normal, line.clone());
Some(line)
}
pub(crate) fn refuse_missing_manifest(project: &std::path::Path) -> Option<i32> {
if project.join("composer.json").exists() {
return None;
}
let cwd = std::fs::canonicalize(project).unwrap_or_else(|_| project.to_path_buf());
vivacity_core::say!(
"Composer could not find a composer.json file in {}\nTo initialize a project, please create a composer.json file. See https://getcomposer.org/basic-usage",
cwd.display()
);
Some(1)
}
pub(crate) fn refuse_invalid_root(manifest: &serde_json::Value) -> Option<i32> {
let err = vivacity_resolver::root::manifest_error(manifest)?;
vivacity_core::say_always!("{err}");
vivacity_core::io::github_action_error(&err.to_string());
Some(1)
}
pub(crate) 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(),
}
}
pub(crate) 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(),
}
}