use super::*;
pub(crate) 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),
}
}
pub(crate) 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 {
vivacity_core::say!(
"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} ")
};
vivacity_core::say!();
vivacity_core::say!(
"What about running composer global require symfony/thanks && composer thanks now?"
);
vivacity_core::say!(
"This will spread some {love} by sending a {star} to the GitHub repositories of your fellow package maintainers."
);
}
vivacity_core::say!();
if !sync {
vivacity_core::say!("Skip synchronizing package.json with PHP packages");
} else if !enabled {
vivacity_core::say!("Synchronizing package.json is disabled: \"symfony/flex\" not found in the root composer.json");
}
if enabled {
vivacity_core::say!(
"Run composer recipes at any time to see the status of your Symfony recipes."
);
vivacity_core::say!();
}
}
pub(crate) 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())
}
pub(crate) 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)
}
pub(crate) 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()
})
}
pub(crate) 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()
})
}
pub(crate) 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)
}
pub(crate) 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
}
pub(crate) 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)
}
pub(crate) 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())
})?;
}
}
vivacity_core::say!();
if flex_downloader_enabled(manifest) {
vivacity_core::say!(
"Run composer recipes at any time to see the status of your Symfony recipes."
);
vivacity_core::say!();
}
Ok(())
}
pub(crate) 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
}
#[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);
}
}