diff options
Diffstat (limited to 'crates/shirabe/src/dependency_resolver')
26 files changed, 919 insertions, 374 deletions
diff --git a/crates/shirabe/src/dependency_resolver/decisions.rs b/crates/shirabe/src/dependency_resolver/decisions.rs index db1068d..22b6fa4 100644 --- a/crates/shirabe/src/dependency_resolver/decisions.rs +++ b/crates/shirabe/src/dependency_resolver/decisions.rs @@ -1,11 +1,11 @@ //! ref: composer/src/Composer/DependencyResolver/Decisions.php -use std::fmt; -use indexmap::IndexMap; -use shirabe_php_shim::LogicException; use crate::dependency_resolver::pool::Pool; use crate::dependency_resolver::rule::Rule; use crate::dependency_resolver::solver_bug_exception::SolverBugException; +use indexmap::IndexMap; +use shirabe_php_shim::LogicException; +use std::fmt; #[derive(Debug)] pub struct Decisions { @@ -43,16 +43,28 @@ impl Decisions { pub fn conflict(&self, literal: i64) -> bool { let package_id = literal.abs(); - (self.decision_map.contains_key(&package_id) && self.decision_map[&package_id] > 0 && literal < 0) - || (self.decision_map.contains_key(&package_id) && self.decision_map[&package_id] < 0 && literal > 0) + (self.decision_map.contains_key(&package_id) + && self.decision_map[&package_id] > 0 + && literal < 0) + || (self.decision_map.contains_key(&package_id) + && self.decision_map[&package_id] < 0 + && literal > 0) } pub fn decided(&self, literal_or_package_id: i64) -> bool { - self.decision_map.get(&literal_or_package_id.abs()).copied().unwrap_or(0) != 0 + self.decision_map + .get(&literal_or_package_id.abs()) + .copied() + .unwrap_or(0) + != 0 } pub fn undecided(&self, literal_or_package_id: i64) -> bool { - self.decision_map.get(&literal_or_package_id.abs()).copied().unwrap_or(0) == 0 + self.decision_map + .get(&literal_or_package_id.abs()) + .copied() + .unwrap_or(0) + == 0 } pub fn decided_install(&self, literal_or_package_id: i64) -> bool { @@ -79,10 +91,17 @@ impl Decisions { } } - panic!("{}", LogicException { - message: format!("Did not find a decision rule using {}", literal_or_package_id), - code: 0, - }.message); + panic!( + "{}", + LogicException { + message: format!( + "Did not find a decision rule using {}", + literal_or_package_id + ), + code: 0, + } + .message + ); } pub fn at_offset(&self, queue_offset: usize) -> &(i64, Rule) { @@ -133,7 +152,8 @@ impl Decisions { } pub fn current(&self) -> Option<&(i64, Rule)> { - self.iterator_cursor.and_then(|cursor| self.decision_queue.get(cursor)) + self.iterator_cursor + .and_then(|cursor| self.decision_queue.get(cursor)) } pub fn key(&self) -> Option<usize> { @@ -141,13 +161,9 @@ impl Decisions { } pub fn next(&mut self) { - self.iterator_cursor = self.iterator_cursor.and_then(|cursor| { - if cursor > 0 { - Some(cursor - 1) - } else { - None - } - }); + self.iterator_cursor = self + .iterator_cursor + .and_then(|cursor| if cursor > 0 { Some(cursor - 1) } else { None }); } pub fn valid(&self) -> bool { @@ -163,11 +179,19 @@ impl Decisions { let previous_decision = self.decision_map.get(&package_id).copied().unwrap_or(0); if previous_decision != 0 { - let literal_string = self.pool.literal_to_pretty_string(literal, &IndexMap::new()); + let literal_string = self + .pool + .literal_to_pretty_string(literal, &IndexMap::new()); let package = self.pool.literal_to_package(literal); - panic!("{}", SolverBugException::new( - format!("Trying to decide {} on level {}, even though {} was previously decided as {}.", literal_string, level, package, previous_decision) - ).0.message); + panic!( + "{}", + SolverBugException::new(format!( + "Trying to decide {} on level {}, even though {} was previously decided as {}.", + literal_string, level, package, previous_decision + )) + .0 + .message + ); } if literal > 0 { diff --git a/crates/shirabe/src/dependency_resolver/default_policy.rs b/crates/shirabe/src/dependency_resolver/default_policy.rs index d84863b..f647327 100644 --- a/crates/shirabe/src/dependency_resolver/default_policy.rs +++ b/crates/shirabe/src/dependency_resolver/default_policy.rs @@ -51,8 +51,12 @@ impl DefaultPolicy { ignore_replace: bool, ) -> i64 { if a.get_name() == b.get_name() { - let a_aliased = (a.as_any() as &dyn Any).downcast_ref::<AliasPackage>().is_some(); - let b_aliased = (b.as_any() as &dyn Any).downcast_ref::<AliasPackage>().is_some(); + let a_aliased = (a.as_any() as &dyn Any) + .downcast_ref::<AliasPackage>() + .is_some(); + let b_aliased = (b.as_any() as &dyn Any) + .downcast_ref::<AliasPackage>() + .is_some(); if a_aliased && !b_aliased { return -1; } @@ -108,7 +112,9 @@ impl DefaultPolicy { let best_literals: Vec<i64> = literals .iter() .copied() - .filter(|&literal| pool.literal_to_package(literal).get_version() == preferred_version) + .filter(|&literal| { + pool.literal_to_package(literal).get_version() == preferred_version + }) .collect(); if !best_literals.is_empty() { return best_literals; @@ -174,15 +180,28 @@ impl DefaultPolicy { } impl PolicyInterface for DefaultPolicy { - fn version_compare(&self, a: &dyn PackageInterface, b: &dyn PackageInterface, operator: &str) -> bool { + fn version_compare( + &self, + a: &dyn PackageInterface, + b: &dyn PackageInterface, + operator: &str, + ) -> bool { if self.prefer_stable { let stab_a = a.get_stability().to_string(); let stab_b = b.get_stability().to_string(); if stab_a != stab_b { let (mut stab_a, mut stab_b) = (stab_a, stab_b); - if self.prefer_lowest && self.prefer_dev_over_prerelease && "stable" != stab_a && "stable" != stab_b { - if stab_a == "dev" { stab_a = "stable".to_string(); } - if stab_b == "dev" { stab_b = "stable".to_string(); } + if self.prefer_lowest + && self.prefer_dev_over_prerelease + && "stable" != stab_a + && "stable" != stab_b + { + if stab_a == "dev" { + stab_a = "stable".to_string(); + } + if stab_b == "dev" { + stab_b = "stable".to_string(); + } } return STABILITIES.get(stab_a.as_str()).copied().unwrap_or(0) < STABILITIES.get(stab_b.as_str()).copied().unwrap_or(0); @@ -213,7 +232,11 @@ impl PolicyInterface for DefaultPolicy { literals.sort(); let result_cache_key = format!( "{}{}", - literals.iter().map(|l| l.to_string()).collect::<Vec<_>>().join(","), + literals + .iter() + .map(|l| l.to_string()) + .collect::<Vec<_>>() + .join(","), required_package.as_deref().unwrap_or("") ); let pool_id = pool as *const Pool as i64; @@ -231,12 +254,8 @@ impl PolicyInterface for DefaultPolicy { for name_literals in packages.values_mut() { name_literals.sort_by(|&a, &b| { - let cache_key = format!( - "i{}.{}{}", - a, - b, - required_package.as_deref().unwrap_or("") - ); + let cache_key = + format!("i{}.{}{}", a, b, required_package.as_deref().unwrap_or("")); { let cache = self.sorting_cache_per_pool.borrow(); if let Some(pool_cache) = cache.get(&pool_id) { @@ -269,12 +288,7 @@ impl PolicyInterface for DefaultPolicy { let mut selected: Vec<i64> = packages.into_values().flatten().collect(); selected.sort_by(|&a, &b| { - let cache_key = format!( - "{}.{}{}", - a, - b, - required_package.as_deref().unwrap_or("") - ); + let cache_key = format!("{}.{}{}", a, b, required_package.as_deref().unwrap_or("")); { let cache = self.sorting_cache_per_pool.borrow(); if let Some(pool_cache) = cache.get(&pool_id) { diff --git a/crates/shirabe/src/dependency_resolver/generic_rule.rs b/crates/shirabe/src/dependency_resolver/generic_rule.rs index 520d483..f30d612 100644 --- a/crates/shirabe/src/dependency_resolver/generic_rule.rs +++ b/crates/shirabe/src/dependency_resolver/generic_rule.rs @@ -1,8 +1,8 @@ //! ref: composer/src/Composer/DependencyResolver/GenericRule.php -use anyhow::Result; -use shirabe_php_shim::{hash_raw, implode, unpack, RuntimeException, PHP_VERSION_ID}; use crate::dependency_resolver::rule::Rule; +use anyhow::Result; +use shirabe_php_shim::{PHP_VERSION_ID, RuntimeException, hash_raw, implode, unpack}; pub struct GenericRule { inner: Rule, @@ -10,7 +10,11 @@ pub struct GenericRule { } impl GenericRule { - pub fn new(mut literals: Vec<i64>, reason: shirabe_php_shim::PhpMixed, reason_data: shirabe_php_shim::PhpMixed) -> Self { + pub fn new( + mut literals: Vec<i64>, + reason: shirabe_php_shim::PhpMixed, + reason_data: shirabe_php_shim::PhpMixed, + ) -> Self { let inner = Rule::new(reason, reason_data); literals.sort(); Self { inner, literals } @@ -21,8 +25,17 @@ impl GenericRule { } pub fn get_hash(&self) -> Result<i64> { - let joined = self.literals.iter().map(|l| l.to_string()).collect::<Vec<_>>().join(","); - let algo = if PHP_VERSION_ID > 80100 { "xxh3" } else { "sha1" }; + let joined = self + .literals + .iter() + .map(|l| l.to_string()) + .collect::<Vec<_>>() + .join(","); + let algo = if PHP_VERSION_ID > 80100 { + "xxh3" + } else { + "sha1" + }; let binary = hash_raw(algo, &joined); let data = unpack("ihash", &binary); match data { @@ -33,13 +46,15 @@ impl GenericRule { Err(RuntimeException { message: format!("Failed unpacking: {}", joined), code: 0, - }.into()) + } + .into()) } } None => Err(RuntimeException { message: format!("Failed unpacking: {}", joined), code: 0, - }.into()), + } + .into()), } } @@ -52,7 +67,11 @@ impl GenericRule { } pub fn to_string(&self) -> String { - let prefix = if self.inner.is_disabled() { "disabled(" } else { "(" }; + let prefix = if self.inner.is_disabled() { + "disabled(" + } else { + "(" + }; let mut result = prefix.to_string(); for (i, literal) in self.literals.iter().enumerate() { if i != 0 { @@ -67,7 +86,9 @@ impl GenericRule { pub trait RuleLiterals { fn get_literals(&self) -> &Vec<i64>; - fn is_multi_conflict_rule(&self) -> bool { false } + fn is_multi_conflict_rule(&self) -> bool { + false + } } impl RuleLiterals for GenericRule { diff --git a/crates/shirabe/src/dependency_resolver/local_repo_transaction.rs b/crates/shirabe/src/dependency_resolver/local_repo_transaction.rs index 5797a3b..dca5c1a 100644 --- a/crates/shirabe/src/dependency_resolver/local_repo_transaction.rs +++ b/crates/shirabe/src/dependency_resolver/local_repo_transaction.rs @@ -1,8 +1,8 @@ //! ref: composer/src/Composer/DependencyResolver/LocalRepoTransaction.php +use super::transaction::Transaction; use crate::repository::installed_repository_interface::InstalledRepositoryInterface; use crate::repository::repository_interface::RepositoryInterface; -use super::transaction::Transaction; #[derive(Debug)] pub struct LocalRepoTransaction { @@ -10,7 +10,10 @@ pub struct LocalRepoTransaction { } impl LocalRepoTransaction { - pub fn new(locked_repository: &dyn RepositoryInterface, local_repository: &dyn InstalledRepositoryInterface) -> Self { + pub fn new( + locked_repository: &dyn RepositoryInterface, + local_repository: &dyn InstalledRepositoryInterface, + ) -> Self { Self { inner: Transaction::new( local_repository.get_packages(), diff --git a/crates/shirabe/src/dependency_resolver/lock_transaction.rs b/crates/shirabe/src/dependency_resolver/lock_transaction.rs index 4b4cc32..44becb0 100644 --- a/crates/shirabe/src/dependency_resolver/lock_transaction.rs +++ b/crates/shirabe/src/dependency_resolver/lock_transaction.rs @@ -39,9 +39,8 @@ impl LockTransaction { }; this.set_result_packages(pool, decisions); let all = this.result_packages.get("all").cloned().unwrap_or_default(); - let present: Vec<Box<dyn PackageInterface>> = this.present_map.values() - .map(|p| p.clone_box()) - .collect(); + let present: Vec<Box<dyn PackageInterface>> = + this.present_map.values().map(|p| p.clone_box()).collect(); this.inner = Transaction::new(present, all); this } @@ -58,9 +57,15 @@ impl LockTransaction { if literal > 0 { let package = pool.literal_to_package(literal); - result_packages.get_mut("all").unwrap().push(package.clone_box()); + result_packages + .get_mut("all") + .unwrap() + .push(package.clone_box()); if !self.unlockable_map.contains_key(&package.get_id()) { - result_packages.get_mut("non-dev").unwrap().push(package.clone_box()); + result_packages + .get_mut("non-dev") + .unwrap() + .push(package.clone_box()); } } } @@ -81,22 +86,37 @@ impl LockTransaction { while i < remaining_dev.len() { if package.get_name() == remaining_dev[i].get_name() { let result_package = remaining_dev.remove(i); - self.result_packages.get_mut("non-dev").unwrap().push(result_package); + self.result_packages + .get_mut("non-dev") + .unwrap() + .push(result_package); } else { i += 1; } } } - self.result_packages.insert("dev".to_string(), remaining_dev); + self.result_packages + .insert("dev".to_string(), remaining_dev); } - pub fn get_new_lock_packages(&self, dev_mode: bool, update_mirrors: bool) -> Vec<Box<dyn PackageInterface>> { + pub fn get_new_lock_packages( + &self, + dev_mode: bool, + update_mirrors: bool, + ) -> Vec<Box<dyn PackageInterface>> { let key = if dev_mode { "dev" } else { "non-dev" }; let mut packages = vec![]; - let source = self.result_packages.get(key).map(|v| v.as_slice()).unwrap_or_default(); + let source = self + .result_packages + .get(key) + .map(|v| v.as_slice()) + .unwrap_or_default(); for package in source { - if (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>().is_some() { + if (package.as_any() as &dyn Any) + .downcast_ref::<AliasPackage>() + .is_some() + { continue; } @@ -129,7 +149,9 @@ impl LockTransaction { continue; } - if let Some(concrete_pkg) = (present_package.as_any() as &dyn Any).downcast_ref::<Package>() { + if let Some(concrete_pkg) = + (present_package.as_any() as &dyn Any).downcast_ref::<Package>() + { concrete_pkg.set_source_url(package.get_source_url()); concrete_pkg.set_source_mirrors(package.get_source_mirrors()); } @@ -167,10 +189,15 @@ impl LockTransaction { if let Some(all_packages) = self.result_packages.get("all") { for package in all_packages { - if (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>().is_some() { + if (package.as_any() as &dyn Any) + .downcast_ref::<AliasPackage>() + .is_some() + { let mut i = 0; while i < remaining_aliases.len() { - if remaining_aliases[i].get("package").map(|s| s.as_str()) == Some(package.get_name()) { + if remaining_aliases[i].get("package").map(|s| s.as_str()) + == Some(package.get_name()) + { used_aliases.push(remaining_aliases.remove(i)); } else { i += 1; @@ -189,7 +216,10 @@ impl LockTransaction { used_aliases } - pub fn get_operations(&self) -> &Vec<Box<dyn crate::dependency_resolver::operation::operation_interface::OperationInterface>> { + pub fn get_operations( + &self, + ) -> &Vec<Box<dyn crate::dependency_resolver::operation::operation_interface::OperationInterface>> + { self.inner.get_operations() } } diff --git a/crates/shirabe/src/dependency_resolver/mod.rs b/crates/shirabe/src/dependency_resolver/mod.rs new file mode 100644 index 0000000..9154084 --- /dev/null +++ b/crates/shirabe/src/dependency_resolver/mod.rs @@ -0,0 +1,26 @@ +pub mod decisions; +pub mod default_policy; +pub mod generic_rule; +pub mod local_repo_transaction; +pub mod lock_transaction; +pub mod multi_conflict_rule; +pub mod operation; +pub mod policy_interface; +pub mod pool; +pub mod pool_builder; +pub mod pool_optimizer; +pub mod problem; +pub mod request; +pub mod rule; +pub mod rule2_literals; +pub mod rule_set; +pub mod rule_set_generator; +pub mod rule_set_iterator; +pub mod rule_watch_chain; +pub mod rule_watch_graph; +pub mod rule_watch_node; +pub mod security_advisory_pool_filter; +pub mod solver; +pub mod solver_bug_exception; +pub mod solver_problems_exception; +pub mod transaction; diff --git a/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs b/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs index 172b6f4..b15434e 100644 --- a/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs +++ b/crates/shirabe/src/dependency_resolver/multi_conflict_rule.rs @@ -1,9 +1,9 @@ //! ref: composer/src/Composer/DependencyResolver/MultiConflictRule.php -use anyhow::Result; -use shirabe_php_shim::{hash_raw, PHP_VERSION_ID, RuntimeException}; use crate::dependency_resolver::generic_rule::RuleLiterals; use crate::dependency_resolver::rule::Rule; +use anyhow::Result; +use shirabe_php_shim::{PHP_VERSION_ID, RuntimeException, hash_raw}; #[derive(Debug)] pub struct MultiConflictRule { @@ -12,12 +12,17 @@ pub struct MultiConflictRule { } impl MultiConflictRule { - pub fn new(mut literals: Vec<i64>, reason: shirabe_php_shim::PhpMixed, reason_data: shirabe_php_shim::PhpMixed) -> Result<Self> { + pub fn new( + mut literals: Vec<i64>, + reason: shirabe_php_shim::PhpMixed, + reason_data: shirabe_php_shim::PhpMixed, + ) -> Result<Self> { if literals.len() < 3 { return Err(RuntimeException { message: "multi conflict rule requires at least 3 literals".to_string(), code: 0, - }.into()); + } + .into()); } // sort all packages ascending by id @@ -34,8 +39,17 @@ impl MultiConflictRule { } pub fn get_hash(&self) -> Result<i64> { - let joined = self.literals.iter().map(|l| l.to_string()).collect::<Vec<_>>().join(","); - let algo = if PHP_VERSION_ID > 80100 { "xxh3" } else { "sha1" }; + let joined = self + .literals + .iter() + .map(|l| l.to_string()) + .collect::<Vec<_>>() + .join(","); + let algo = if PHP_VERSION_ID > 80100 { + "xxh3" + } else { + "sha1" + }; let binary = hash_raw(algo, &format!("c:{}", joined)); let data = shirabe_php_shim::unpack("ihash", &binary); match data { @@ -46,13 +60,15 @@ impl MultiConflictRule { Err(RuntimeException { message: format!("Failed unpacking: {}", joined), code: 0, - }.into()) + } + .into()) } } None => Err(RuntimeException { message: format!("Failed unpacking: {}", joined), code: 0, - }.into()), + } + .into()), } } diff --git a/crates/shirabe/src/dependency_resolver/operation/mod.rs b/crates/shirabe/src/dependency_resolver/operation/mod.rs new file mode 100644 index 0000000..ffb0ac7 --- /dev/null +++ b/crates/shirabe/src/dependency_resolver/operation/mod.rs @@ -0,0 +1,7 @@ +pub mod install_operation; +pub mod mark_alias_installed_operation; +pub mod mark_alias_uninstalled_operation; +pub mod operation_interface; +pub mod solver_operation; +pub mod uninstall_operation; +pub mod update_operation; diff --git a/crates/shirabe/src/dependency_resolver/operation/update_operation.rs b/crates/shirabe/src/dependency_resolver/operation/update_operation.rs index eb6e9d6..618ecee 100644 --- a/crates/shirabe/src/dependency_resolver/operation/update_operation.rs +++ b/crates/shirabe/src/dependency_resolver/operation/update_operation.rs @@ -13,7 +13,10 @@ pub struct UpdateOperation { impl UpdateOperation { pub fn new(initial: Box<dyn PackageInterface>, target: Box<dyn PackageInterface>) -> Self { - Self { initial_package: initial, target_package: target } + Self { + initial_package: initial, + target_package: target, + } } pub fn get_initial_package(&self) -> &dyn PackageInterface { @@ -24,19 +27,36 @@ impl UpdateOperation { self.target_package.as_ref() } - pub fn format(initial_package: &dyn PackageInterface, target_package: &dyn PackageInterface, lock: bool) -> String { - let mut from_version = initial_package.get_full_pretty_version(false, PackageInterface::DISPLAY_SOURCE_REF); - let mut to_version = target_package.get_full_pretty_version(false, PackageInterface::DISPLAY_SOURCE_REF); + pub fn format( + initial_package: &dyn PackageInterface, + target_package: &dyn PackageInterface, + lock: bool, + ) -> String { + let mut from_version = + initial_package.get_full_pretty_version(false, PackageInterface::DISPLAY_SOURCE_REF); + let mut to_version = + target_package.get_full_pretty_version(false, PackageInterface::DISPLAY_SOURCE_REF); - if from_version == to_version && initial_package.get_source_reference() != target_package.get_source_reference() { - from_version = initial_package.get_full_pretty_version(true, PackageInterface::DISPLAY_SOURCE_REF); - to_version = target_package.get_full_pretty_version(true, PackageInterface::DISPLAY_SOURCE_REF); - } else if from_version == to_version && initial_package.get_dist_reference() != target_package.get_dist_reference() { - from_version = initial_package.get_full_pretty_version(true, PackageInterface::DISPLAY_DIST_REF); - to_version = target_package.get_full_pretty_version(true, PackageInterface::DISPLAY_DIST_REF); + if from_version == to_version + && initial_package.get_source_reference() != target_package.get_source_reference() + { + from_version = + initial_package.get_full_pretty_version(true, PackageInterface::DISPLAY_SOURCE_REF); + to_version = + target_package.get_full_pretty_version(true, PackageInterface::DISPLAY_SOURCE_REF); + } else if from_version == to_version + && initial_package.get_dist_reference() != target_package.get_dist_reference() + { + from_version = + initial_package.get_full_pretty_version(true, PackageInterface::DISPLAY_DIST_REF); + to_version = + target_package.get_full_pretty_version(true, PackageInterface::DISPLAY_DIST_REF); } - let action_name = if VersionParser::is_upgrade(&initial_package.get_version(), &target_package.get_version()) { + let action_name = if VersionParser::is_upgrade( + &initial_package.get_version(), + &target_package.get_version(), + ) { "Upgrading" } else { "Downgrading" @@ -62,7 +82,11 @@ impl OperationInterface for UpdateOperation { } fn show(&self, lock: bool) -> String { - Self::format(self.initial_package.as_ref(), self.target_package.as_ref(), lock) + Self::format( + self.initial_package.as_ref(), + self.target_package.as_ref(), + lock, + ) } fn to_string(&self) -> String { diff --git a/crates/shirabe/src/dependency_resolver/policy_interface.rs b/crates/shirabe/src/dependency_resolver/policy_interface.rs index 279cf38..a48cd4b 100644 --- a/crates/shirabe/src/dependency_resolver/policy_interface.rs +++ b/crates/shirabe/src/dependency_resolver/policy_interface.rs @@ -4,7 +4,17 @@ use crate::dependency_resolver::pool::Pool; use crate::package::package_interface::PackageInterface; pub trait PolicyInterface { - fn version_compare(&self, a: &dyn PackageInterface, b: &dyn PackageInterface, operator: &str) -> bool; + fn version_compare( + &self, + a: &dyn PackageInterface, + b: &dyn PackageInterface, + operator: &str, + ) -> bool; - fn select_preferred_packages(&self, pool: &Pool, literals: Vec<i64>, required_package: Option<String>) -> Vec<i64>; + fn select_preferred_packages( + &self, + pool: &Pool, + literals: Vec<i64>, + required_package: Option<String>, + ) -> Vec<i64>; } diff --git a/crates/shirabe/src/dependency_resolver/pool.rs b/crates/shirabe/src/dependency_resolver/pool.rs index c783f45..e86e4c2 100644 --- a/crates/shirabe/src/dependency_resolver/pool.rs +++ b/crates/shirabe/src/dependency_resolver/pool.rs @@ -3,7 +3,7 @@ use std::fmt; use indexmap::IndexMap; -use shirabe_php_shim::{abs, spl_object_hash, str_pad, Countable, STR_PAD_LEFT}; +use shirabe_php_shim::{Countable, STR_PAD_LEFT, abs, spl_object_hash, str_pad}; use shirabe_semver::compiling_matcher::CompilingMatcher; use shirabe_semver::constraint::constraint::Constraint; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; @@ -48,10 +48,7 @@ impl Pool { unacceptable_fixed_or_locked_packages: Vec<Box<BasePackage>>, removed_versions: IndexMap<String, IndexMap<String, String>>, removed_versions_by_package: IndexMap<String, IndexMap<String, String>>, - security_removed_versions: IndexMap< - String, - IndexMap<String, Vec<PartialSecurityAdvisory>>, - >, + security_removed_versions: IndexMap<String, IndexMap<String, Vec<PartialSecurityAdvisory>>>, abandoned_removed_versions: IndexMap<String, IndexMap<String, String>>, ) -> Self { let mut this = Self { @@ -116,7 +113,10 @@ impl Pool { constraint: Option<&dyn ConstraintInterface>, ) -> bool { let empty = IndexMap::new(); - let versions = self.security_removed_versions.get(package_name).unwrap_or(&empty); + let versions = self + .security_removed_versions + .get(package_name) + .unwrap_or(&empty); for (version, _package_with_security_advisories) in versions { if let Some(c) = constraint { if c.matches(&Constraint::new("==", version)) { @@ -135,7 +135,10 @@ impl Pool { constraint: Option<&dyn ConstraintInterface>, ) -> Vec<String> { let empty = IndexMap::new(); - let versions = self.security_removed_versions.get(package_name).unwrap_or(&empty); + let versions = self + .security_removed_versions + .get(package_name) + .unwrap_or(&empty); for (version, package_with_security_advisories) in versions { if let Some(c) = constraint { if c.matches(&Constraint::new("==", version)) { @@ -156,7 +159,10 @@ impl Pool { constraint: Option<&dyn ConstraintInterface>, ) -> bool { let empty = IndexMap::new(); - let versions = self.abandoned_removed_versions.get(package_name).unwrap_or(&empty); + let versions = self + .abandoned_removed_versions + .get(package_name) + .unwrap_or(&empty); for (version, _pretty_version) in versions { if let Some(c) = constraint { if c.matches(&Constraint::new("==", version)) { @@ -280,11 +286,7 @@ impl Pool { let package = self.literal_to_package(literal); let prefix = if installed_map.contains_key(&package.id) { - if literal > 0 { - "keep" - } else { - "remove" - } + if literal > 0 { "keep" } else { "remove" } } else { if literal > 0 { "install" @@ -328,8 +330,7 @@ impl Pool { if replaces.contains_key("0") || provides.contains_key("0") { for link in provides.values() { if link.get_target() == name - && (constraint.is_none() - || constraint.unwrap().matches(link.get_constraint())) + && (constraint.is_none() || constraint.unwrap().matches(link.get_constraint())) { return true; } @@ -337,8 +338,7 @@ impl Pool { for link in replaces.values() { if link.get_target() == name - && (constraint.is_none() - || constraint.unwrap().matches(link.get_constraint())) + && (constraint.is_none() || constraint.unwrap().matches(link.get_constraint())) { return true; } diff --git a/crates/shirabe/src/dependency_resolver/pool_builder.rs b/crates/shirabe/src/dependency_resolver/pool_builder.rs index 0d99587..f518545 100644 --- a/crates/shirabe/src/dependency_resolver/pool_builder.rs +++ b/crates/shirabe/src/dependency_resolver/pool_builder.rs @@ -6,8 +6,8 @@ use shirabe_external_packages::composer::pcre::preg::Preg; use shirabe_external_packages::composer::semver::compiling_matcher::CompilingMatcher; use shirabe_external_packages::composer::semver::intervals::Intervals; use shirabe_php_shim::{ - array_chunk, array_flip, array_map, array_merge, array_search, count, in_array, microtime, - number_format, round, spl_object_hash, sprintf, strpos, LogicException, PhpMixed, + LogicException, PhpMixed, array_chunk, array_flip, array_map, array_merge, array_search, count, + in_array, microtime, number_format, round, spl_object_hash, sprintf, strpos, }; use shirabe_semver::constraint::constraint::Constraint; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; @@ -126,7 +126,11 @@ impl PoolBuilder { self.allowed_types = types; } - pub fn build_pool(&mut self, repositories: Vec<Box<dyn RepositoryInterface>>, request: &mut Request) -> anyhow::Result<Pool> { + pub fn build_pool( + &mut self, + repositories: Vec<Box<dyn RepositoryInterface>>, + request: &mut Request, + ) -> anyhow::Result<Pool> { self.restricted_packages_list = if request.get_restricted_packages().is_some() { Some(array_flip(&request.get_restricted_packages().unwrap())) } else { @@ -139,7 +143,8 @@ impl PoolBuilder { if request.get_locked_repository().is_none() { return Err(LogicException { - message: "No lock repo present and yet a partial update was requested.".to_string(), + message: "No lock repo present and yet a partial update was requested." + .to_string(), code: 0, } .into()); @@ -165,9 +170,13 @@ impl PoolBuilder { // if they do get unlocked, but by default they are unlocked without update propagation. if locked_package.get_dist_type().as_deref() == Some("path") { let transport_options = locked_package.get_transport_options(); - let symlink_disabled = transport_options.get("symlink").map(|v| v.as_bool() == Some(false)).unwrap_or(false); + let symlink_disabled = transport_options + .get("symlink") + .map(|v| v.as_bool() == Some(false)) + .unwrap_or(false); if !transport_options.contains_key("symlink") || !symlink_disabled { - self.path_repo_unlocked.insert(locked_package.get_name().to_string(), true); + self.path_repo_unlocked + .insert(locked_package.get_name().to_string(), true); continue; } } @@ -180,11 +189,17 @@ impl PoolBuilder { for package in request.get_fixed_or_locked_packages() { // using MatchAllConstraint here because fixed packages do not need to retrigger // loading any packages - self.loaded_packages.insert(package.get_name().to_string(), Box::new(MatchAllConstraint::new())); + self.loaded_packages.insert( + package.get_name().to_string(), + Box::new(MatchAllConstraint::new()), + ); // replace means conflict, so if a fixed package replaces a name, no need to load that one, packages would conflict anyways for (_k, link) in &package.get_replaces() { - self.loaded_packages.insert(link.get_target().to_string(), Box::new(MatchAllConstraint::new())); + self.loaded_packages.insert( + link.get_target().to_string(), + Box::new(MatchAllConstraint::new()), + ); } // TODO in how far can we do the above for conflicts? It's more tricky cause conflicts can be limited to @@ -193,7 +208,8 @@ impl PoolBuilder { let in_root_or_platform = package .get_repository() .map(|r| { - r.as_any().is::<RootPackageRepository>() || r.as_any().is::<PlatformRepository>() + r.as_any().is::<RootPackageRepository>() + || r.as_any().is::<PlatformRepository>() }) .unwrap_or(false); if in_root_or_platform @@ -206,7 +222,8 @@ impl PoolBuilder { { self.load_package(request, &repositories, &*package, false)?; } else { - self.unacceptable_fixed_or_locked_packages.push(package.clone_box()); + self.unacceptable_fixed_or_locked_packages + .push(package.clone_box()); } } @@ -216,7 +233,8 @@ impl PoolBuilder { continue; } - self.packages_to_load.insert(package_name.clone(), constraint.clone_box()); + self.packages_to_load + .insert(package_name.clone(), constraint.clone_box()); self.max_extended_reqs.insert(package_name.clone(), true); } @@ -253,7 +271,8 @@ impl PoolBuilder { None => continue, }; - let mut package_and_aliases: IndexMap<i64, Box<dyn BasePackage>> = IndexMap::new(); + let mut package_and_aliases: IndexMap<i64, Box<dyn BasePackage>> = + IndexMap::new(); package_and_aliases.insert(i, package.clone_box()); if let Some(aliases) = self.alias_map.get(&spl_object_hash(&*package)) { for (idx, alias) in aliases { @@ -263,7 +282,11 @@ impl PoolBuilder { let mut found = false; for (_idx, package_or_alias) in &package_and_aliases { - if CompilingMatcher::matches(&*constraint, Constraint::OP_EQ, package_or_alias.get_version()) { + if CompilingMatcher::matches( + &*constraint, + Constraint::OP_EQ, + package_or_alias.get_version(), + ) { found = true; } } @@ -287,7 +310,10 @@ impl PoolBuilder { self.root_aliases.clone(), self.root_references.clone(), self.packages.values().map(|p| p.clone_box()).collect(), - self.unacceptable_fixed_or_locked_packages.iter().map(|p| p.clone_box()).collect(), + self.unacceptable_fixed_or_locked_packages + .iter() + .map(|p| p.clone_box()) + .collect(), ); self.event_dispatcher .as_mut() @@ -300,12 +326,16 @@ impl PoolBuilder { .enumerate() .map(|(i, p)| (i as i64, p)) .collect(); - self.unacceptable_fixed_or_locked_packages = pre_pool_create_event.get_unacceptable_fixed_packages(); + self.unacceptable_fixed_or_locked_packages = + pre_pool_create_event.get_unacceptable_fixed_packages(); } let mut pool = Pool::new( self.packages.values().map(|p| p.clone_box()).collect(), - self.unacceptable_fixed_or_locked_packages.iter().map(|p| p.clone_box()).collect(), + self.unacceptable_fixed_or_locked_packages + .iter() + .map(|p| p.clone_box()) + .collect(), ); self.alias_map = IndexMap::new(); @@ -330,7 +360,12 @@ impl PoolBuilder { Ok(pool) } - fn mark_package_name_for_loading(&mut self, request: &Request, name: &str, constraint: Box<dyn ConstraintInterface>) { + fn mark_package_name_for_loading( + &mut self, + request: &Request, + name: &str, + constraint: Box<dyn ConstraintInterface>, + ) { // Skip platform requires at this stage if PlatformRepository::is_platform_package(name) { return; @@ -399,7 +434,11 @@ impl PoolBuilder { self.loaded_packages.shift_remove(name); } - fn load_packages_marked_for_loading(&mut self, request: &mut Request, repositories: &Vec<Box<dyn RepositoryInterface>>) -> anyhow::Result<()> { + fn load_packages_marked_for_loading( + &mut self, + request: &mut Request, + repositories: &Vec<Box<dyn RepositoryInterface>>, + ) -> anyhow::Result<()> { let to_remove: Vec<String> = self .packages_to_load .keys() @@ -420,7 +459,8 @@ impl PoolBuilder { .map(|(k, v)| (k.clone(), v.clone_box())) .collect(); for (name, constraint) in &snapshot { - self.loaded_packages.insert(name.clone(), constraint.clone_box()); + self.loaded_packages + .insert(name.clone(), constraint.clone_box()); } // Load packages in chunks of 50 to prevent memory usage build-up due to caches of all sorts @@ -432,7 +472,12 @@ impl PoolBuilder { // never need to load anything else from them let is_locked_repo = request .get_locked_repository() - .map(|lr| std::ptr::eq(lr as *const _ as *const u8, repository.as_ref() as *const _ as *const u8)) + .map(|lr| { + std::ptr::eq( + lr as *const _ as *const u8, + repository.as_ref() as *const _ as *const u8, + ) + }) .unwrap_or(false); if repository.as_any().is::<PlatformRepository>() || is_locked_repo { continue; @@ -447,17 +492,28 @@ impl PoolBuilder { package_batch, &self.acceptable_stabilities, &self.stability_flags, - self.loaded_per_repo.get(&(repo_index as i64)).cloned().unwrap_or_default(), + self.loaded_per_repo + .get(&(repo_index as i64)) + .cloned() + .unwrap_or_default(), ); - let names_found = result.get("namesFound").and_then(|v| v.as_list()).cloned().unwrap_or_default(); + let names_found = result + .get("namesFound") + .and_then(|v| v.as_list()) + .cloned() + .unwrap_or_default(); for name in &names_found { // avoid loading the same package again from other repositories once it has been found if let Some(b) = package_batches.get_mut(batch_index) { b.shift_remove(name.as_string().unwrap_or("")); } } - let packages_in_result = result.get("packages").and_then(|v| v.as_list()).cloned().unwrap_or_default(); + let packages_in_result = result + .get("packages") + .and_then(|v| v.as_list()) + .cloned() + .unwrap_or_default(); for package in &packages_in_result { let pkg = match package.as_package_interface() { Some(p) => p, @@ -472,7 +528,11 @@ impl PoolBuilder { if in_array(pkg.get_type(), &self.ignored_types, true) || (self.allowed_types.is_some() - && !in_array(pkg.get_type(), self.allowed_types.as_ref().unwrap(), true)) + && !in_array( + pkg.get_type(), + self.allowed_types.as_ref().unwrap(), + true, + )) { continue; } @@ -495,7 +555,13 @@ impl PoolBuilder { Ok(()) } - fn load_package(&mut self, request: &mut Request, repositories: &Vec<Box<dyn RepositoryInterface>>, package: &dyn BasePackage, propagate_update: bool) -> anyhow::Result<()> { + fn load_package( + &mut self, + request: &mut Request, + repositories: &Vec<Box<dyn RepositoryInterface>>, + package: &dyn BasePackage, + propagate_update: bool, + ) -> anyhow::Result<()> { let index = self.index_counter; self.index_counter += 1; self.packages.insert(index, package.clone_box()); @@ -537,19 +603,20 @@ impl PoolBuilder { } else { package.clone_box() }; - let alias_package: Box<dyn BasePackage> = if base_package.as_any().is::<CompletePackage>() { - Box::new(CompleteAliasPackage::new( - base_package.clone_box(), - alias.get("alias_normalized").cloned().unwrap_or_default(), - alias.get("alias").cloned().unwrap_or_default(), - )) - } else { - Box::new(AliasPackage::new( - base_package.clone_box(), - alias.get("alias_normalized").cloned().unwrap_or_default(), - alias.get("alias").cloned().unwrap_or_default(), - )) - }; + let alias_package: Box<dyn BasePackage> = + if base_package.as_any().is::<CompletePackage>() { + Box::new(CompleteAliasPackage::new( + base_package.clone_box(), + alias.get("alias_normalized").cloned().unwrap_or_default(), + alias.get("alias").cloned().unwrap_or_default(), + )) + } else { + Box::new(AliasPackage::new( + base_package.clone_box(), + alias.get("alias_normalized").cloned().unwrap_or_default(), + alias.get("alias").cloned().unwrap_or_default(), + )) + }; // PHP: $aliasPackage->setRootPackageAlias(true); // BasePackage doesn't expose this directly; the AliasPackage trait method handles it. @@ -577,7 +644,9 @@ impl PoolBuilder { if propagate_update && request.get_update_allow_transitive_dependencies() { let skipped_root_requires = self.get_skipped_root_requires(request, &require); - if request.get_update_allow_transitive_root_dependencies() || 0 == count(&skipped_root_requires) { + if request.get_update_allow_transitive_root_dependencies() + || 0 == count(&skipped_root_requires) + { self.unlock_package(request, repositories, &require)?; self.mark_package_name_for_loading(request, &require, link_constraint); } else { @@ -588,7 +657,9 @@ impl PoolBuilder { } } } - } else if self.path_repo_unlocked.contains_key(&require) && !self.loaded_packages.contains_key(&require) { + } else if self.path_repo_unlocked.contains_key(&require) + && !self.loaded_packages.contains_key(&require) + { // if doing a partial update and a package depends on a path-repo-unlocked package which is not referenced by the root, we need to ensure it gets loaded as it was not loaded by the request's root requirements // and would not be loaded above if update propagation is not allowed (which happens if the requirer is itself a path-repo-unlocked package) or if transitive deps are not allowed to be unlocked self.mark_package_name_for_loading(request, &require, link_constraint); @@ -603,10 +674,14 @@ impl PoolBuilder { if propagate_update && request.get_update_allow_transitive_dependencies() { for (_k, link) in &package.get_replaces() { let replace = link.get_target().to_string(); - if self.loaded_packages.contains_key(&replace) && self.skipped_load.contains_key(&replace) { + if self.loaded_packages.contains_key(&replace) + && self.skipped_load.contains_key(&replace) + { let skipped_root_requires = self.get_skipped_root_requires(request, &replace); - if request.get_update_allow_transitive_root_dependencies() || 0 == count(&skipped_root_requires) { + if request.get_update_allow_transitive_root_dependencies() + || 0 == count(&skipped_root_requires) + { self.unlock_package(request, repositories, &replace)?; // the replaced package only needs to be loaded if something else requires it self.mark_package_name_for_loading_if_required(request, &replace); @@ -660,7 +735,11 @@ impl PoolBuilder { for (_k, link) in &package_or_replacer.get_replaces() { if root_requires.contains_key(link.get_target()) { if name != package_or_replacer.get_name() { - matches.push(format!("{} (via replace of {})", package_or_replacer.get_name(), name)); + matches.push(format!( + "{} (via replace of {})", + package_or_replacer.get_name(), + name + )); } else { matches.push(package_or_replacer.get_name().to_string()); } @@ -735,7 +814,12 @@ impl PoolBuilder { /// Reverts the decision to use a locked package if a partial update with transitive dependencies /// found that this package actually needs to be updated - fn unlock_package(&mut self, request: &mut Request, repositories: &Vec<Box<dyn RepositoryInterface>>, name: &str) -> anyhow::Result<()> { + fn unlock_package( + &mut self, + request: &mut Request, + repositories: &Vec<Box<dyn RepositoryInterface>>, + name: &str, + ) -> anyhow::Result<()> { let skipped: Vec<Box<dyn PackageInterface>> = self .skipped_load .get(name) @@ -744,21 +828,35 @@ impl PoolBuilder { for package_or_replacer in &skipped { // if we unfixed a replaced package name, we also need to unfix the replacer itself // as long as it was not unfixed yet - if package_or_replacer.get_name() != name && self.skipped_load.contains_key(package_or_replacer.get_name()) { + if package_or_replacer.get_name() != name + && self + .skipped_load + .contains_key(package_or_replacer.get_name()) + { let replacer_name = package_or_replacer.get_name().to_string(); if request.get_update_allow_transitive_root_dependencies() - || (!self.is_root_require(request, name) && !self.is_root_require(request, &replacer_name)) + || (!self.is_root_require(request, name) + && !self.is_root_require(request, &replacer_name)) { self.unlock_package(request, repositories, &replacer_name)?; if self.is_root_require(request, &replacer_name) { - self.mark_package_name_for_loading(request, &replacer_name, Box::new(MatchAllConstraint::new())); + self.mark_package_name_for_loading( + request, + &replacer_name, + Box::new(MatchAllConstraint::new()), + ); } else { - let pkgs: Vec<Box<dyn BasePackage>> = self.packages.values().map(|p| p.clone_box()).collect(); + let pkgs: Vec<Box<dyn BasePackage>> = + self.packages.values().map(|p| p.clone_box()).collect(); for loaded_package in &pkgs { let requires = loaded_package.get_requires(); if let Some(req_link) = requires.get(&replacer_name) { - self.mark_package_name_for_loading(request, &replacer_name, req_link.get_constraint()); + self.mark_package_name_for_loading( + request, + &replacer_name, + req_link.get_constraint(), + ); } } } @@ -784,10 +882,15 @@ impl PoolBuilder { self.path_repo_unlocked.shift_remove(name); // remove locked package by this name which was already initialized - let locked_packages: Vec<Box<dyn BasePackage>> = request.get_locked_packages().iter().map(|p| p.clone_box()).collect(); + let locked_packages: Vec<Box<dyn BasePackage>> = request + .get_locked_packages() + .iter() + .map(|p| p.clone_box()) + .collect(); for locked_package in &locked_packages { if locked_package.as_alias_package().is_none() && locked_package.get_name() == name { - let pkgs: Vec<Box<dyn BasePackage>> = self.packages.values().map(|p| p.clone_box()).collect(); + let pkgs: Vec<Box<dyn BasePackage>> = + self.packages.values().map(|p| p.clone_box()).collect(); let index_opt = array_search(&**locked_package, &pkgs, true); if let Some(index) = index_opt { request.unlock_package(&**locked_package); @@ -798,23 +901,47 @@ impl PoolBuilder { // satisfied their requirements // and if this package is replacing another that is required by a locked or fixed package, ensure // that we load that replaced package in case an update to this package removes the replacement - let fixed_or_locked: Vec<Box<dyn BasePackage>> = request.get_fixed_or_locked_packages().iter().map(|p| p.clone_box()).collect(); + let fixed_or_locked: Vec<Box<dyn BasePackage>> = request + .get_fixed_or_locked_packages() + .iter() + .map(|p| p.clone_box()) + .collect(); for fixed_or_locked_package in &fixed_or_locked { - if std::ptr::eq(fixed_or_locked_package.as_ref() as *const _, locked_package.as_ref() as *const _) { + if std::ptr::eq( + fixed_or_locked_package.as_ref() as *const _, + locked_package.as_ref() as *const _, + ) { continue; } - if self.skipped_load.contains_key(fixed_or_locked_package.get_name()) { + if self + .skipped_load + .contains_key(fixed_or_locked_package.get_name()) + { let requires = fixed_or_locked_package.get_requires(); if let Some(req_link) = requires.get(locked_package.get_name()) { - self.mark_package_name_for_loading(request, locked_package.get_name(), req_link.get_constraint()); + self.mark_package_name_for_loading( + request, + locked_package.get_name(), + req_link.get_constraint(), + ); } for (_k, replace) in &locked_package.get_replaces() { - if requires.contains_key(replace.get_target()) && self.skipped_load.contains_key(replace.get_target()) { - self.unlock_package(request, repositories, replace.get_target())?; + if requires.contains_key(replace.get_target()) + && self.skipped_load.contains_key(replace.get_target()) + { + self.unlock_package( + request, + repositories, + replace.get_target(), + )?; // this package is in $requires so no need to call markPackageNameForLoadingIfRequired - self.mark_package_name_for_loading(request, replace.get_target(), replace.get_constraint()); + self.mark_package_name_for_loading( + request, + replace.get_target(), + replace.get_constraint(), + ); } } } @@ -827,21 +954,37 @@ impl PoolBuilder { fn mark_package_name_for_loading_if_required(&mut self, request: &Request, name: &str) { if self.is_root_require(request, name) { - self.mark_package_name_for_loading(request, name, request.get_requires()[name].clone_box()); + self.mark_package_name_for_loading( + request, + name, + request.get_requires()[name].clone_box(), + ); } - let pkgs: Vec<Box<dyn BasePackage>> = self.packages.values().map(|p| p.clone_box()).collect(); + let pkgs: Vec<Box<dyn BasePackage>> = + self.packages.values().map(|p| p.clone_box()).collect(); for package in &pkgs { for (_k, link) in &package.get_requires() { if name == link.get_target() { - self.mark_package_name_for_loading(request, link.get_target(), link.get_constraint()); + self.mark_package_name_for_loading( + request, + link.get_target(), + link.get_constraint(), + ); } } } } - fn remove_loaded_package(&mut self, _request: &Request, repositories: &Vec<Box<dyn RepositoryInterface>>, package: &dyn BasePackage, index: i64) { - let repos_box: Vec<Box<dyn RepositoryInterface>> = repositories.iter().map(|r| r.clone_box()).collect(); + fn remove_loaded_package( + &mut self, + _request: &Request, + repositories: &Vec<Box<dyn RepositoryInterface>>, + package: &dyn BasePackage, + index: i64, + ) { + let repos_box: Vec<Box<dyn RepositoryInterface>> = + repositories.iter().map(|r| r.clone_box()).collect(); let repo_index = match package.get_repository() { Some(repo) => array_search(&*repo, &repos_box, true).unwrap_or(-1), None => -1, @@ -881,7 +1024,11 @@ impl PoolBuilder { let before = microtime(true); let total = count(&pool.get_packages()) as f64; - let pool = self.pool_optimizer.as_mut().unwrap().optimize(request, pool); + let pool = self + .pool_optimizer + .as_mut() + .unwrap() + .optimize(request, pool); let filtered = total - (count(&pool.get_packages()) as f64); @@ -890,7 +1037,10 @@ impl PoolBuilder { } self.io.write_with_verbosity( - &sprintf("Pool optimizer completed in %.3f seconds", &[(microtime(true) - before).into()]), + &sprintf( + "Pool optimizer completed in %.3f seconds", + &[(microtime(true) - before).into()], + ), true, IOInterface::VERY_VERBOSE, ); @@ -910,7 +1060,12 @@ impl PoolBuilder { pool } - fn run_security_advisory_filter(&mut self, pool: Pool, repositories: &Vec<Box<dyn RepositoryInterface>>, request: &Request) -> Pool { + fn run_security_advisory_filter( + &mut self, + pool: Pool, + repositories: &Vec<Box<dyn RepositoryInterface>>, + request: &Request, + ) -> Pool { if self.security_advisory_pool_filter.is_none() { return pool; } @@ -920,7 +1075,11 @@ impl PoolBuilder { let before = microtime(true); let total = count(&pool.get_packages()) as f64; - let pool = self.security_advisory_pool_filter.as_mut().unwrap().filter(pool, repositories, request); + let pool = self.security_advisory_pool_filter.as_mut().unwrap().filter( + pool, + repositories, + request, + ); let filtered = total - (count(&pool.get_packages()) as f64); @@ -929,7 +1088,10 @@ impl PoolBuilder { } self.io.write_with_verbosity( - &sprintf("Security advisory pool filter completed in %.3f seconds", &[(microtime(true) - before).into()]), + &sprintf( + "Security advisory pool filter completed in %.3f seconds", + &[(microtime(true) - before).into()], + ), true, IOInterface::VERY_VERBOSE, ); diff --git a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs index 94b6771..b71af14 100644 --- a/crates/shirabe/src/dependency_resolver/pool_optimizer.rs +++ b/crates/shirabe/src/dependency_resolver/pool_optimizer.rs @@ -4,7 +4,7 @@ use std::any::Any; use anyhow::Result; use indexmap::IndexMap; -use shirabe_php_shim::{implode, ksort, spl_object_hash, LogicException, PhpMixed}; +use shirabe_php_shim::{LogicException, PhpMixed, implode, ksort, spl_object_hash}; use shirabe_semver::compiling_matcher::CompilingMatcher; use shirabe_semver::constraint::constraint::Constraint; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; @@ -28,7 +28,8 @@ pub struct PoolOptimizer { irremovable_packages: IndexMap<i64, bool>, /// @var array<string, array<string, ConstraintInterface>> - require_constraints_per_package: IndexMap<String, IndexMap<String, Box<dyn ConstraintInterface>>>, + require_constraints_per_package: + IndexMap<String, IndexMap<String, Box<dyn ConstraintInterface>>>, /// @var array<string, array<string, ConstraintInterface>> conflict_constraints_per_package: @@ -104,10 +105,7 @@ impl PoolOptimizer { // Extract requested package requirements for (require, constraint) in request.get_requires() { // TODO(phase-b): clone Box<dyn ConstraintInterface> - self.extract_require_constraints_per_package( - require, - todo!("constraint.clone_box()"), - ); + self.extract_require_constraints_per_package(require, todo!("constraint.clone_box()")); } // First pass over all packages to extract information and mark package constraints irremovable @@ -131,9 +129,7 @@ impl PoolOptimizer { // Keep track of alias packages for every package so if either the alias or aliased is kept // we keep the others as they are a unit of packages really - if let Some(alias_pkg) = - (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() - { + if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { self.aliases_per_package .entry(alias_pkg.get_alias_of().id) .or_insert_with(Vec::new) @@ -162,7 +158,9 @@ impl PoolOptimizer { continue; } - let constraint = irremovable_package_constraints.get(package.get_name()).unwrap(); + let constraint = irremovable_package_constraints + .get(package.get_name()) + .unwrap(); if CompilingMatcher::r#match( constraint.as_ref(), Constraint::OP_EQ, @@ -175,9 +173,7 @@ impl PoolOptimizer { fn mark_package_irremovable(&mut self, package: &BasePackage) { self.irremovable_packages.insert(package.id, true); - if let Some(alias_pkg) = - (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() - { + if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { // recursing here so aliasesPerPackage for the aliasOf can be checked // and all its aliases marked as irremovable as well self.mark_package_irremovable(alias_pkg.get_alias_of()); @@ -279,8 +275,7 @@ impl PoolOptimizer { package.get_version(), ) { // Use the same hash part as the regular require hash because that's what the replacement does - group_hash_parts - .push(format!("require:{}", link.get_constraint())); + group_hash_parts.push(format!("require:{}", link.get_constraint())); } } } @@ -294,8 +289,7 @@ impl PoolOptimizer { Constraint::OP_EQ, package.get_version(), ) { - group_hash_parts - .push(format!("conflict:{}", conflict_constraint)); + group_hash_parts.push(format!("conflict:{}", conflict_constraint)); } } } @@ -350,7 +344,10 @@ impl PoolOptimizer { literals.push(package.id); } - for preferred_literal in self.policy.select_preferred_packages(pool, literals.clone()) { + for preferred_literal in self + .policy + .select_preferred_packages(pool, literals.clone()) + { self.keep_package( &pool.literal_to_package(preferred_literal), &identical_definitions_per_package, @@ -392,7 +389,10 @@ impl PoolOptimizer { // However, the majority of projects are going to specify their constraints already pretty // much in the best variant possible. In other words, we'd be wasting time here and it would actually hurt // performance more than the additional few packages that could be filtered out would benefit the process. - subhash.insert(link.get_target().to_string(), link.get_constraint().to_string()); + subhash.insert( + link.get_target().to_string(), + link.get_constraint().to_string(), + ); } // Sort for best result @@ -442,9 +442,7 @@ impl PoolOptimizer { self.packages_to_remove.shift_remove(&package.id); - if let Some(alias_pkg) = - (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() - { + if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { // recursing here so aliasesPerPackage for the aliasOf can be checked // and all its aliases marked to be kept as well self.keep_package( @@ -467,7 +465,9 @@ impl PoolOptimizer { let pkg = if let Some(alias_pkg) = (pkg.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { - if alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS { + if alias_pkg.get_pretty_version() + == VersionParser::DEFAULT_BRANCH_ALIAS + { alias_pkg.get_alias_of().clone_box() } else { pkg.clone_box() @@ -498,9 +498,7 @@ impl PoolOptimizer { // record all the versions of the package group so we can list them later in Problem output for name in alias_package.get_names(false) { - if let Some(per_name) = - package_identical_definition_lookup.get(&alias_package.id) - { + if let Some(per_name) = package_identical_definition_lookup.get(&alias_package.id) { if let Some(package_group_pointers) = per_name.get(&name) { let package_group = identical_definitions_per_package .get(&name) diff --git a/crates/shirabe/src/dependency_resolver/problem.rs b/crates/shirabe/src/dependency_resolver/problem.rs index 0108487..50b651d 100644 --- a/crates/shirabe/src/dependency_resolver/problem.rs +++ b/crates/shirabe/src/dependency_resolver/problem.rs @@ -5,9 +5,9 @@ use indexmap::IndexMap; use shirabe_external_packages::composer::pcre::preg::Preg; use shirabe_external_packages::symfony::console::formatter::output_formatter::OutputFormatter; use shirabe_php_shim::{ - defined, extension_loaded, implode, in_array, php_to_string, phpversion, sprintf, - spl_object_hash, str_replace, str_starts_with, stripos, strpos, strtolower, substr, - substr_count, version_compare, LogicException, PhpMixed, + LogicException, PhpMixed, defined, extension_loaded, implode, in_array, php_to_string, + phpversion, spl_object_hash, sprintf, str_replace, str_starts_with, stripos, strpos, + strtolower, substr, substr_count, version_compare, }; use shirabe_semver::constraint::constraint::Constraint; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; @@ -134,10 +134,7 @@ impl Problem { fn get_sortable_string(&self, pool: &Pool, rule: &Rule) -> String { match rule.get_reason() { - Rule::RULE_ROOT_REQUIRE => rule - .get_reason_data() - .as_array() - .unwrap()["packageName"] + Rule::RULE_ROOT_REQUIRE => rule.get_reason_data().as_array().unwrap()["packageName"] .as_string() .unwrap() .to_string(), @@ -302,12 +299,9 @@ impl Problem { }; if versions_list.len() > 1 { // remove the s from requires/conflicts to correct grammar - let message_var = Preg::replace( - r"{^(%s%s (?:require|conflict))s}", - "$1", - message, - ) - .unwrap_or(message.clone()); + let message_var = + Preg::replace(r"{^(%s%s (?:require|conflict))s}", "$1", message) + .unwrap_or(message.clone()); result.push(sprintf( &message_var, &[ @@ -331,7 +325,11 @@ impl Problem { } } - format!("\n{}- {}", indent, implode(&format!("\n{}- ", indent), &result)) + format!( + "\n{}- {}", + indent, + implode(&format!("\n{}- ", indent), &result) + ) } pub fn is_caused_by_lock( @@ -585,7 +583,13 @@ impl Problem { ), format!( "found {}. The # character in branch names is replaced by a + character. Make sure to require it as \"{}\".", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ), str_replace("#", "+", &c.get_pretty_string()) ), ); @@ -602,8 +606,7 @@ impl Problem { let filtered: Vec<&Box<dyn PackageInterface>> = packages .iter() .filter(|p| { - root_reqs[package_name] - .matches(&Constraint::new("==", &p.get_version())) + root_reqs[package_name].matches(&Constraint::new("==", &p.get_version())) }) .collect(); if filtered.len() == 0 { @@ -615,7 +618,13 @@ impl Problem { ), format!( "found {} but {} with your root composer.json require ({}).", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ), if Self::has_multiple_names(&packages) { "these conflict" } else { @@ -646,7 +655,13 @@ impl Problem { ), format!( "found {} but {} with your temporary update constraint ({}:{}).", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ), if Self::has_multiple_names(&packages) { "these conflict" } else { @@ -664,9 +679,7 @@ impl Problem { let fixed_constraint = Constraint::new("==", &lp.get_version()); let filtered: Vec<&Box<dyn PackageInterface>> = packages .iter() - .filter(|p| { - fixed_constraint.matches(&Constraint::new("==", &p.get_version())) - }) + .filter(|p| fixed_constraint.matches(&Constraint::new("==", &p.get_version()))) .collect(); if filtered.len() == 0 { return ( @@ -677,7 +690,13 @@ impl Problem { ), format!( "found {} but the package is fixed to {} (lock file version) by a partial update and that version does not match. Make sure you list it as an argument for the update command.", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ), lp.get_pretty_version() ), ); @@ -698,7 +717,13 @@ impl Problem { ), format!( "found {} in the lock file but not in remote repositories, make sure you avoid updating this package to keep the one from the lock file.", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false) + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ) ), ); } @@ -712,7 +737,13 @@ impl Problem { ), format!( "found {} but these were not loaded, because they are abandoned and you configured \"block-abandoned\" to true in your \"audit\" config.", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false) + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ) ), ); } @@ -781,7 +812,13 @@ impl Problem { ), format!( "found {} but these were not loaded, because they are affected by security advisories (\"{}\"). Go to https://packagist.org/security-advisories/ to find advisory details. To ignore the advisories, add them to the audit \"ignore\" config. To turn the feature off entirely, you can set \"block-insecure\" to false in your \"audit\" config.", - Self::get_package_list(&packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &packages, + is_verbose, + Some(pool), + constraint, + false + ), implode("\", \"", &advisories_list) ), ); @@ -900,9 +937,8 @@ impl Problem { let top_package = all_repos_packages.first(); if let Some(tp) = top_package { if tp.is_root_package_interface() { - suffix = - " See https://getcomposer.org/dep-on-root for details and assistance." - .to_string(); + suffix = " See https://getcomposer.org/dep-on-root for details and assistance." + .to_string(); } } @@ -1019,7 +1055,9 @@ impl Problem { let mut prepared_strings: Vec<String> = Vec::new(); for (name, mut package) in prepared { // remove the implicit default branch alias to avoid cruft in the display - if package.versions.contains_key(VersionParser::DEFAULT_BRANCH_ALIAS) + if package + .versions + .contains_key(VersionParser::DEFAULT_BRANCH_ALIAS) && has_default_branch.contains_key(&name) { package @@ -1222,7 +1260,13 @@ impl Problem { ), format!( "satisfiable by {} from {} but {} {} is the root package and cannot be modified. See https://getcomposer.org/dep-on-root for details and assistance.", - Self::get_package_list(&next_repo_packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &next_repo_packages, + is_verbose, + Some(pool), + constraint, + false + ), next_repo.get_repo_name(), top_package.get_pretty_name(), top_package.get_pretty_version() @@ -1237,7 +1281,13 @@ impl Problem { let mut suggestion = format!( "Make sure you either fix the {} or avoid updating this package to keep the one present in the lock file ({}).", reason, - Self::get_package_list(&next_repo_packages, is_verbose, Some(pool), constraint, false) + Self::get_package_list( + &next_repo_packages, + is_verbose, + Some(pool), + constraint, + false + ) ); // symlinked path repos cannot be locked so do not suggest keeping it locked if next_repo_packages[0].get_dist_type() == "path" { @@ -1260,7 +1310,13 @@ impl Problem { ), format!( "found {} but {} not match your {} and {} therefore not installable. {}", - Self::get_package_list(higher_repo_packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + higher_repo_packages, + is_verbose, + Some(pool), + constraint, + false + ), if singular { "it does" } else { "these do" }, reason, if singular { "is" } else { "are" }, @@ -1277,10 +1333,26 @@ impl Problem { ), format!( "satisfiable by {} from {} but {} from {} has higher repository priority. The packages from the higher priority repository do not match your {} and are therefore not installable. That repository is canonical so the lower priority repo's packages are not installable. See https://getcomposer.org/repoprio for details and assistance.", - Self::get_package_list(&next_repo_packages, is_verbose, Some(pool), constraint, false), + Self::get_package_list( + &next_repo_packages, + is_verbose, + Some(pool), + constraint, + false + ), next_repo.get_repo_name(), - Self::get_package_list(higher_repo_packages, is_verbose, Some(pool), constraint, false), - higher_repo_packages.first().unwrap().get_repository().get_repo_name(), + Self::get_package_list( + higher_repo_packages, + is_verbose, + Some(pool), + constraint, + false + ), + higher_repo_packages + .first() + .unwrap() + .get_repository() + .get_repo_name(), reason ), ) @@ -1313,7 +1385,10 @@ impl Problem { "{} or {}", implode( ", ", - &versions[..versions.len() - 1].iter().cloned().collect::<Vec<_>>() + &versions[..versions.len() - 1] + .iter() + .cloned() + .collect::<Vec<_>>() ), last ) @@ -1343,7 +1418,11 @@ impl Problem { if providers.len() > 0 { let provider_count = providers.len() as i64; let slice = if provider_count > max_providers + 1 { - providers.iter().take(max_providers as usize).cloned().collect::<Vec<_>>() + providers + .iter() + .take(max_providers as usize) + .cloned() + .collect::<Vec<_>>() } else { providers.clone() }; diff --git a/crates/shirabe/src/dependency_resolver/request.rs b/crates/shirabe/src/dependency_resolver/request.rs index 9aef975..e1f8c1e 100644 --- a/crates/shirabe/src/dependency_resolver/request.rs +++ b/crates/shirabe/src/dependency_resolver/request.rs @@ -1,7 +1,7 @@ //! ref: composer/src/Composer/DependencyResolver/Request.php use indexmap::IndexMap; -use shirabe_php_shim::{spl_object_hash, strtolower, LogicException}; +use shirabe_php_shim::{LogicException, spl_object_hash, strtolower}; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; use shirabe_semver::constraint::match_all_constraint::MatchAllConstraint; diff --git a/crates/shirabe/src/dependency_resolver/rule.rs b/crates/shirabe/src/dependency_resolver/rule.rs index 8c015b4..1ba1dd7 100644 --- a/crates/shirabe/src/dependency_resolver/rule.rs +++ b/crates/shirabe/src/dependency_resolver/rule.rs @@ -5,8 +5,8 @@ use std::any::Any; use anyhow::Result; use indexmap::IndexMap; use shirabe_php_shim::{ - abs, array_filter, array_keys, array_shift, array_values, implode, is_object, LogicException, - PhpMixed, + LogicException, PhpMixed, abs, array_filter, array_keys, array_shift, array_values, implode, + is_object, }; use shirabe_semver::constraint::constraint::Constraint; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; @@ -156,7 +156,9 @@ impl Rule { if pool.is_unacceptable_fixed_or_locked_package(p) { return true; } - if !link.get_constraint().matches(&Constraint::new("=", p.get_version())) + if !link + .get_constraint() + .matches(&Constraint::new("=", p.get_version())) { return true; } @@ -173,7 +175,11 @@ impl Rule { } if self.get_reason() == Self::RULE_ROOT_REQUIRE { - if let ReasonData::RootRequire { package_name, constraint } = self.get_reason_data() { + if let ReasonData::RootRequire { + package_name, + constraint, + } = self.get_reason_data() + { if PlatformRepository::is_platform_package(package_name) { return false; } @@ -254,9 +260,10 @@ impl Rule { let reason_data = self.get_reason_data(); let (package_name, constraint): (&str, &dyn ConstraintInterface) = match reason_data { - ReasonData::RootRequire { package_name, constraint } => { - (package_name.as_str(), constraint.as_ref()) - } + ReasonData::RootRequire { + package_name, + constraint, + } => (package_name.as_str(), constraint.as_ref()), _ => return String::new(), }; @@ -273,7 +280,9 @@ impl Rule { let packages_non_alias: Vec<Box<BasePackage>> = packages .iter() .filter(|p| { - (p.as_any() as &dyn Any).downcast_ref::<AliasPackage>().is_none() + (p.as_any() as &dyn Any) + .downcast_ref::<AliasPackage>() + .is_none() }) .map(|p| p.clone_box()) .collect(); @@ -293,7 +302,13 @@ impl Rule { "Root composer.json requires {} {} -> satisfiable by {}.", package_name, constraint.get_pretty_string(), - self.format_packages_unique(pool, packages, is_verbose, Some(constraint), false), + self.format_packages_unique( + pool, + packages, + is_verbose, + Some(constraint), + false + ), ) } @@ -335,8 +350,11 @@ impl Rule { // swap literals if they are not in the right order with package2 being the conflicter if link.get_source() == package1.get_name() { std::mem::swap(&mut package1, &mut package2); - conflict_target = - format!("{} {}", package1.get_pretty_name(), link.get_pretty_constraint().unwrap_or("")); + conflict_target = format!( + "{} {}", + package1.get_pretty_name(), + link.get_pretty_constraint().unwrap_or("") + ); } // if the conflict is not directly against the package but something it provides/replaces, @@ -347,14 +365,16 @@ impl Rule { for provide in package1.get_provides().values() { if provide.get_target() == link.get_target() { provide_type = Some("provides"); - provided = Some(provide.get_pretty_constraint().unwrap_or("").to_string()); + provided = + Some(provide.get_pretty_constraint().unwrap_or("").to_string()); break; } } for replace in package1.get_replaces().values() { if replace.get_target() == link.get_target() { provide_type = Some("replaces"); - provided = Some(replace.get_pretty_constraint().unwrap_or("").to_string()); + provided = + Some(replace.get_pretty_constraint().unwrap_or("").to_string()); break; } } @@ -371,7 +391,11 @@ impl Rule { } } - format!("{} conflicts with {}.", package2.get_pretty_string(), conflict_target) + format!( + "{} conflicts with {}.", + package2.get_pretty_string(), + conflict_target + ) } r if r == Self::RULE_PACKAGE_REQUIRES => { @@ -488,14 +512,18 @@ impl Rule { return format!( "Only one of these can be installed: {}. {}", - self.format_packages_unique_from_literals(pool, &literals, is_verbose, None, true), + self.format_packages_unique_from_literals( + pool, &literals, is_verbose, None, true + ), reason, ); } format!( "You can only install one version of a package, so only one of these can be installed: {}.", - self.format_packages_unique_from_literals(pool, &literals, is_verbose, None, true), + self.format_packages_unique_from_literals( + pool, &literals, is_verbose, None, true + ), ) } r if r == Self::RULE_LEARNED => { @@ -512,7 +540,11 @@ impl Rule { let group = if installed_map.contains_key(&package.id) { if *literal > 0 { "keep" } else { "remove" } } else { - if *literal > 0 { "install" } else { "don't install" } + if *literal > 0 { + "install" + } else { + "don't install" + } }; groups @@ -604,7 +636,13 @@ impl Rule { packages.push(package); } - Problem::get_package_list(packages, is_verbose, pool, constraint, use_removed_version_group) + Problem::get_package_list( + packages, + is_verbose, + pool, + constraint, + use_removed_version_group, + ) } /// Helper for cases where literals come as int IDs (PHP supports both via union). @@ -620,13 +658,17 @@ impl Rule { for literal in literals { packages.push(pool.literal_to_package(*literal).clone_box()); } - Problem::get_package_list(packages, is_verbose, pool, constraint, use_removed_version_group) + Problem::get_package_list( + packages, + is_verbose, + pool, + constraint, + use_removed_version_group, + ) } fn deduplicate_default_branch_alias(&self, package: Box<BasePackage>) -> Box<BasePackage> { - if let Some(alias_pkg) = - (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() - { + if let Some(alias_pkg) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { if alias_pkg.get_pretty_version() == VersionParser::DEFAULT_BRANCH_ALIAS { return alias_pkg.get_alias_of().clone_box(); } diff --git a/crates/shirabe/src/dependency_resolver/rule2_literals.rs b/crates/shirabe/src/dependency_resolver/rule2_literals.rs index 9d3aefc..e86c93d 100644 --- a/crates/shirabe/src/dependency_resolver/rule2_literals.rs +++ b/crates/shirabe/src/dependency_resolver/rule2_literals.rs @@ -12,7 +12,12 @@ pub struct Rule2Literals { } impl Rule2Literals { - pub fn new(literal1: i64, literal2: i64, reason: shirabe_php_shim::PhpMixed, reason_data: shirabe_php_shim::PhpMixed) -> Self { + pub fn new( + literal1: i64, + literal2: i64, + reason: shirabe_php_shim::PhpMixed, + reason_data: shirabe_php_shim::PhpMixed, + ) -> Self { let (literal1, literal2) = if literal1 < literal2 { (literal1, literal2) } else { @@ -52,7 +57,11 @@ impl Rule2Literals { } pub fn to_string(&self) -> String { - let prefix = if self.inner.is_disabled() { "disabled(" } else { "(" }; + let prefix = if self.inner.is_disabled() { + "disabled(" + } else { + "(" + }; format!("{}{}|{})", prefix, self.literal1, self.literal2) } } diff --git a/crates/shirabe/src/dependency_resolver/rule_set.rs b/crates/shirabe/src/dependency_resolver/rule_set.rs index 36009d9..4fc7928 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set.rs @@ -53,7 +53,8 @@ impl RuleSet { return Err(OutOfBoundsException { message: format!("Unknown rule type: {}", r#type), code: 0, - }.into()); + } + .into()); } let hash = rule.get_hash(); @@ -66,13 +67,19 @@ impl RuleSet { } } - self.rules.entry(r#type).or_insert_with(Vec::new).push(rule.clone()); + self.rules + .entry(r#type) + .or_insert_with(Vec::new) + .push(rule.clone()); rule.set_type(r#type); self.rule_by_id.insert(self.next_rule_id, rule.clone()); self.next_rule_id += 1; - self.rules_by_hash.entry(hash).or_insert_with(Vec::new).push(rule); + self.rules_by_hash + .entry(hash) + .or_insert_with(Vec::new) + .push(rule); Ok(()) } diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs index a2066ef..9c803d6 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs @@ -12,8 +12,8 @@ use crate::dependency_resolver::policy_interface::PolicyInterface; use crate::dependency_resolver::pool::Pool; use crate::dependency_resolver::request::Request; use crate::dependency_resolver::rule::Rule; -use crate::dependency_resolver::rule2_literals::Rule2Literals; use crate::dependency_resolver::rule_set::RuleSet; +use crate::dependency_resolver::rule2_literals::Rule2Literals; use crate::filter::platform_requirement_filter::ignore_list_platform_requirement_filter::IgnoreListPlatformRequirementFilter; use crate::filter::platform_requirement_filter::platform_requirement_filter_factory::PlatformRequirementFilterFactory; use crate::filter::platform_requirement_filter::platform_requirement_filter_interface::PlatformRequirementFilterInterface; @@ -65,7 +65,11 @@ impl RuleSetGenerator { literals.push(provider.get_id()); } - Some(GenericRule::new(literals, PhpMixed::Int(reason), reason_data)) + Some(GenericRule::new( + literals, + PhpMixed::Int(reason), + reason_data, + )) } /// Creates a rule to install at least one of a set of packages. @@ -126,7 +130,9 @@ impl RuleSetGenerator { reason_data, )) } else { - Rule::from(MultiConflictRule::new(literals, PhpMixed::Int(reason), reason_data).unwrap()) + Rule::from( + MultiConflictRule::new(literals, PhpMixed::Int(reason), reason_data).unwrap(), + ) } } @@ -202,8 +208,8 @@ impl RuleSetGenerator { if platform_requirement_filter.is_ignored(link.get_target()) { continue; } else if let Some(ignore_list_filter) = (platform_requirement_filter as &dyn Any) - .downcast_ref::<IgnoreListPlatformRequirementFilter>() - { + .downcast_ref::<IgnoreListPlatformRequirementFilter>( + ) { constraint = ignore_list_filter .filter_constraint(link.get_target(), constraint, true) .unwrap_or(constraint); @@ -230,11 +236,8 @@ impl RuleSetGenerator { &mut self, platform_requirement_filter: &dyn PlatformRequirementFilterInterface, ) { - let packages: Vec<Box<dyn PackageInterface>> = self - .added_map - .values() - .map(|p| p.clone_box()) - .collect(); + let packages: Vec<Box<dyn PackageInterface>> = + self.added_map.values().map(|p| p.clone_box()).collect(); for package in &packages { for link in package.get_conflicts().values() { @@ -247,8 +250,8 @@ impl RuleSetGenerator { if platform_requirement_filter.is_ignored(link.get_target()) { continue; } else if let Some(ignore_list_filter) = (platform_requirement_filter as &dyn Any) - .downcast_ref::<IgnoreListPlatformRequirementFilter>() - { + .downcast_ref::<IgnoreListPlatformRequirementFilter>( + ) { constraint = ignore_list_filter .filter_constraint(link.get_target(), constraint, false) .unwrap_or(constraint); @@ -286,11 +289,8 @@ impl RuleSetGenerator { for (name, packages) in names_packages { if packages.len() > 1 { let reason = Rule::RULE_PACKAGE_SAME_NAME; - let rule = self.create_multi_conflict_rule( - &packages, - reason, - PhpMixed::String(name), - ); + let rule = + self.create_multi_conflict_rule(&packages, reason, PhpMixed::String(name)); self.add_rule(RuleSet::TYPE_PACKAGE, Some(rule)); } } @@ -309,15 +309,13 @@ impl RuleSetGenerator { } // otherwise, looks like a bug - return Err(anyhow::anyhow!( - shirabe_php_shim::LogicException { - message: format!( - "Fixed package {} was not added to solver pool.", - package.get_pretty_string() - ), - code: 0, - } - )); + return Err(anyhow::anyhow!(shirabe_php_shim::LogicException { + message: format!( + "Fixed package {} was not added to solver pool.", + package.get_pretty_string() + ), + code: 0, + })); } self.add_rules_for_package(package.clone_box(), platform_requirement_filter); @@ -340,8 +338,8 @@ impl RuleSetGenerator { if platform_requirement_filter.is_ignored(package_name) { continue; } else if let Some(ignore_list_filter) = (platform_requirement_filter as &dyn Any) - .downcast_ref::<IgnoreListPlatformRequirementFilter>() - { + .downcast_ref::<IgnoreListPlatformRequirementFilter>( + ) { constraint = ignore_list_filter .filter_constraint(package_name, constraint, true) .unwrap_or(constraint); @@ -406,8 +404,8 @@ impl RuleSetGenerator { request: &Request, platform_requirement_filter: Option<Box<dyn PlatformRequirementFilterInterface>>, ) -> anyhow::Result<RuleSet> { - let platform_requirement_filter = - platform_requirement_filter.unwrap_or_else(PlatformRequirementFilterFactory::ignore_nothing); + let platform_requirement_filter = platform_requirement_filter + .unwrap_or_else(PlatformRequirementFilterFactory::ignore_nothing); self.add_rules_for_request(request, &*platform_requirement_filter)?; diff --git a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs index e2b67f4..f66a277 100644 --- a/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs +++ b/crates/shirabe/src/dependency_resolver/rule_set_iterator.rs @@ -1,7 +1,7 @@ //! ref: composer/src/Composer/DependencyResolver/RuleSetIterator.php -use indexmap::IndexMap; use crate::dependency_resolver::rule::Rule; +use indexmap::IndexMap; /// Implements PHP \Iterator over a grouped rule set. #[derive(Debug)] diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs index 5428ca1..80c9bee 100644 --- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs +++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs @@ -27,24 +27,38 @@ impl RuleWatchGraph { return; } - if (node.get_rule().as_any() as &dyn Any).downcast_ref::<MultiConflictRule>().is_none() { + if (node.get_rule().as_any() as &dyn Any) + .downcast_ref::<MultiConflictRule>() + .is_none() + { for literal in [node.watch1, node.watch2] { if !self.watch_chains.contains_key(&literal) { self.watch_chains.insert(literal, RuleWatchChain::new()); } - self.watch_chains.get_mut(&literal).unwrap().unshift(node.clone()); + self.watch_chains + .get_mut(&literal) + .unwrap() + .unshift(node.clone()); } } else { for literal in node.get_rule().get_literals() { if !self.watch_chains.contains_key(&literal) { self.watch_chains.insert(literal, RuleWatchChain::new()); } - self.watch_chains.get_mut(&literal).unwrap().unshift(node.clone()); + self.watch_chains + .get_mut(&literal) + .unwrap() + .unshift(node.clone()); } } } - pub fn propagate_literal(&mut self, decided_literal: i64, level: i64, decisions: &mut Decisions) -> Option<Box<dyn Rule>> { + pub fn propagate_literal( + &mut self, + decided_literal: i64, + level: i64, + decisions: &mut Decisions, + ) -> Option<Box<dyn Rule>> { let literal = -decided_literal; if !self.watch_chains.contains_key(&literal) { @@ -56,13 +70,17 @@ impl RuleWatchGraph { chain.rewind(); while chain.valid() { let node = chain.current(); - if (node.get_rule().as_any() as &dyn Any).downcast_ref::<MultiConflictRule>().is_none() { + if (node.get_rule().as_any() as &dyn Any) + .downcast_ref::<MultiConflictRule>() + .is_none() + { let other_watch = node.get_other_watch(literal); if !node.get_rule().is_disabled() && !decisions.satisfy(other_watch) { let rule_literals = node.get_rule().get_literals(); - let alternative_literals: Vec<i64> = rule_literals.into_iter() + let alternative_literals: Vec<i64> = rule_literals + .into_iter() .filter(|&rule_literal| { literal != rule_literal && other_watch != rule_literal @@ -107,6 +125,9 @@ impl RuleWatchGraph { node.move_watch(from_literal, to_literal); self.watch_chains.get_mut(&from_literal).unwrap().remove(); - self.watch_chains.get_mut(&to_literal).unwrap().unshift(node); + self.watch_chains + .get_mut(&to_literal) + .unwrap() + .unshift(node); } } diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs index 4161268..12dd83f 100644 --- a/crates/shirabe/src/dependency_resolver/rule_watch_node.rs +++ b/crates/shirabe/src/dependency_resolver/rule_watch_node.rs @@ -25,7 +25,11 @@ impl RuleWatchNode { let watch1 = if literal_count > 0 { literals[0] } else { 0 }; let watch2 = if literal_count > 1 { literals[1] } else { 0 }; - Self { watch1, watch2, rule } + Self { + watch1, + watch2, + rule, + } } pub fn watch2_on_highest(&mut self, decisions: &Decisions) { diff --git a/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs b/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs index 8c30f60..8caf6bd 100644 --- a/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs +++ b/crates/shirabe/src/dependency_resolver/security_advisory_pool_filter.rs @@ -1,8 +1,5 @@ //! ref: composer/src/Composer/DependencyResolver/SecurityAdvisoryPoolFilter.php -use indexmap::IndexMap; -use shirabe_php_shim::PhpMixed; -use shirabe_semver::constraint::constraint::Constraint; use crate::advisory::audit_config::AuditConfig; use crate::advisory::auditor::Auditor; use crate::dependency_resolver::pool::Pool; @@ -11,6 +8,9 @@ use crate::package::package_interface::PackageInterface; use crate::repository::platform_repository::PlatformRepository; use crate::repository::repository_interface::RepositoryInterface; use crate::repository::repository_set::RepositorySet; +use indexmap::IndexMap; +use shirabe_php_shim::PhpMixed; +use shirabe_semver::constraint::constraint::Constraint; #[derive(Debug)] pub struct SecurityAdvisoryPoolFilter { @@ -20,10 +20,18 @@ pub struct SecurityAdvisoryPoolFilter { impl SecurityAdvisoryPoolFilter { pub fn new(auditor: Auditor, audit_config: AuditConfig) -> Self { - Self { auditor, audit_config } + Self { + auditor, + audit_config, + } } - pub fn filter(&self, pool: Pool, repositories: Vec<Box<dyn RepositoryInterface>>, request: &Request) -> Pool { + pub fn filter( + &self, + pool: Pool, + repositories: Vec<Box<dyn RepositoryInterface>>, + request: &Request, + ) -> Pool { if !self.audit_config.block_insecure { return pool; } @@ -35,15 +43,23 @@ impl SecurityAdvisoryPoolFilter { let mut packages_for_advisories: Vec<Box<dyn PackageInterface>> = vec![]; for package in pool.get_packages() { - if !package.is_root() && !PlatformRepository::is_platform_package(package.get_name()) && !request.is_locked_package(package.as_ref()) { + if !package.is_root() + && !PlatformRepository::is_platform_package(package.get_name()) + && !request.is_locked_package(package.as_ref()) + { packages_for_advisories.push(package); } } // all_advisories: ['advisories' => array<string, array<PartialSecurityAdvisory|SecurityAdvisory>>, ...] - let mut all_advisories: IndexMap<String, PhpMixed> = repo_set.get_matching_security_advisories(&packages_for_advisories, true, true); - if self.auditor.needs_complete_advisory_load(&all_advisories["advisories"], &self.audit_config.ignore_list_for_blocking) { - all_advisories = repo_set.get_matching_security_advisories(&packages_for_advisories, false, true); + let mut all_advisories: IndexMap<String, PhpMixed> = + repo_set.get_matching_security_advisories(&packages_for_advisories, true, true); + if self.auditor.needs_complete_advisory_load( + &all_advisories["advisories"], + &self.audit_config.ignore_list_for_blocking, + ) { + all_advisories = + repo_set.get_matching_security_advisories(&packages_for_advisories, false, true); } // advisory_map: array<string, array<PartialSecurityAdvisory|SecurityAdvisory>> @@ -51,20 +67,35 @@ impl SecurityAdvisoryPoolFilter { &all_advisories["advisories"], &self.audit_config.ignore_list_for_blocking, &self.audit_config.ignore_severity_for_blocking, - )["advisories"].clone().into(); + )["advisories"] + .clone() + .into(); let mut packages: Vec<Box<dyn PackageInterface>> = vec![]; // security_removed_versions: array<string, array<string, array<PartialSecurityAdvisory|SecurityAdvisory>>> - let mut security_removed_versions: IndexMap<String, IndexMap<String, Vec<PhpMixed>>> = IndexMap::new(); + let mut security_removed_versions: IndexMap<String, IndexMap<String, Vec<PhpMixed>>> = + IndexMap::new(); // abandoned_removed_versions: array<string, array<string, string>> - let mut abandoned_removed_versions: IndexMap<String, IndexMap<String, String>> = IndexMap::new(); + let mut abandoned_removed_versions: IndexMap<String, IndexMap<String, String>> = + IndexMap::new(); for package in pool.get_packages() { - if self.audit_config.block_abandoned && !self.auditor.filter_abandoned_packages(vec![package.as_ref()], &self.audit_config.ignore_abandoned_for_blocking).is_empty() { + if self.audit_config.block_abandoned + && !self + .auditor + .filter_abandoned_packages( + vec![package.as_ref()], + &self.audit_config.ignore_abandoned_for_blocking, + ) + .is_empty() + { for package_name in package.get_names(false) { abandoned_removed_versions .entry(package_name) .or_default() - .insert(package.get_version().to_string(), package.get_pretty_version().to_string()); + .insert( + package.get_version().to_string(), + package.get_pretty_version().to_string(), + ); } continue; } @@ -75,7 +106,10 @@ impl SecurityAdvisoryPoolFilter { security_removed_versions .entry(package_name) .or_default() - .insert(package.get_version().to_string(), matching_advisories.clone()); + .insert( + package.get_version().to_string(), + matching_advisories.clone(), + ); } continue; } @@ -83,10 +117,21 @@ impl SecurityAdvisoryPoolFilter { packages.push(package); } - Pool::new(packages, pool.get_unacceptable_fixed_or_locked_packages(), pool.get_all_removed_versions(), pool.get_all_removed_versions_by_package(), security_removed_versions, abandoned_removed_versions) + Pool::new( + packages, + pool.get_unacceptable_fixed_or_locked_packages(), + pool.get_all_removed_versions(), + pool.get_all_removed_versions_by_package(), + security_removed_versions, + abandoned_removed_versions, + ) } - fn get_matching_advisories(&self, package: &dyn PackageInterface, advisory_map: &IndexMap<String, Vec<PhpMixed>>) -> Vec<PhpMixed> { + fn get_matching_advisories( + &self, + package: &dyn PackageInterface, + advisory_map: &IndexMap<String, Vec<PhpMixed>>, + ) -> Vec<PhpMixed> { if package.is_dev() { return vec![]; } diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs index 76de9de..388cccd 100644 --- a/crates/shirabe/src/dependency_resolver/solver.rs +++ b/crates/shirabe/src/dependency_resolver/solver.rs @@ -2,7 +2,9 @@ use indexmap::IndexMap; -use shirabe_php_shim::{array_pop, array_shift, array_unshift, microtime, spl_object_hash, sprintf, PhpMixed}; +use shirabe_php_shim::{ + PhpMixed, array_pop, array_shift, array_unshift, microtime, spl_object_hash, sprintf, +}; use shirabe_semver::constraint::constraint_interface::ConstraintInterface; use crate::dependency_resolver::decisions::Decisions; @@ -183,8 +185,8 @@ impl Solver { continue; } else if let Some(ignore_filter) = platform_requirement_filter .as_any() - .downcast_ref::<IgnoreListPlatformRequirementFilter>() - { + .downcast_ref::<IgnoreListPlatformRequirementFilter>( + ) { constraint = ignore_filter.filter_constraint(package_name, constraint); } @@ -201,8 +203,7 @@ impl Solver { ); // TODO(phase-b): store the constraint inside reason_data; PhpMixed needs to // accept a `dyn ConstraintInterface` wrapper. - reason_data - .insert("constraint".to_string(), PhpMixed::Null); + reason_data.insert("constraint".to_string(), PhpMixed::Null); problem.add_rule(Rule::generic(GenericRule::new( Vec::new(), PhpMixed::Int(Rule::RULE_ROOT_REQUIRE), @@ -233,7 +234,8 @@ impl Solver { true, <dyn IOInterface>::DEBUG, ); - let mut rule_set_generator = RuleSetGenerator::new(self.policy.clone_box(), self.pool.clone()); + let mut rule_set_generator = + RuleSetGenerator::new(self.policy.clone_box(), self.pool.clone()); self.rules = rule_set_generator.get_rules_for(request, platform_requirement_filter.as_ref())?; drop(rule_set_generator); @@ -242,8 +244,7 @@ impl Solver { self.watch_graph = RuleWatchGraph::new(); for rule in self.rules.iter() { - self.watch_graph - .insert(RuleWatchNode::new(rule.clone()))?; + self.watch_graph.insert(RuleWatchNode::new(rule.clone()))?; } // make decisions based on root require/fix assertions @@ -298,11 +299,9 @@ impl Solver { .at_offset(self.propagate_index as usize) .clone(); - let conflict = self.watch_graph.propagate_literal( - decision.0, - level, - &mut self.decisions, - ); + let conflict = + self.watch_graph + .propagate_literal(decision.0, level, &mut self.decisions); self.propagate_index += 1; @@ -333,9 +332,7 @@ impl Solver { self.propagate_index = self.decisions.count() as i64; } - while !self.branches.is_empty() - && self.branches[self.branches.len() - 1].1 >= level - { + while !self.branches.is_empty() && self.branches[self.branches.len() - 1].1 >= level { // PHP: array_pop($this->branches) self.branches.pop(); } @@ -388,8 +385,7 @@ impl Solver { self.rules .add(new_rule.clone().into(), RuleSet::TYPE_LEARNED)?; - self.learned_why - .insert(spl_object_hash(&new_rule), why); + self.learned_why.insert(spl_object_hash(&new_rule), why); let mut rule_node = RuleWatchNode::new(new_rule.clone().into()); rule_node.watch2_on_highest(&self.decisions); @@ -408,9 +404,11 @@ impl Solver { rule: Rule, ) -> anyhow::Result<i64> { // choose best package to install from decisionQueue - let mut literals = - self.policy - .select_preferred_packages(&self.pool, decision_queue, rule.get_required_package()); + let mut literals = self.policy.select_preferred_packages( + &self.pool, + decision_queue, + rule.get_required_package(), + ); let selected_literal = array_shift::<i64>(&mut literals); @@ -422,11 +420,7 @@ impl Solver { self.set_propagate_learn(level, selected_literal, rule) } - fn analyze( - &mut self, - level: i64, - rule: Rule, - ) -> anyhow::Result<(i64, i64, GenericRule, i64)> { + fn analyze(&mut self, level: i64, rule: Rule) -> anyhow::Result<(i64, i64, GenericRule, i64)> { let analyzed_rule = rule.clone(); let mut rule = rule; let mut rule_level = 1_i64; diff --git a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs index 37cbbfe..ddc8746 100644 --- a/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs +++ b/crates/shirabe/src/dependency_resolver/solver_problems_exception.rs @@ -50,10 +50,18 @@ impl SolverProblemsException { for problem in &self.problems { problems.push(format!( "{}\n", - problem.get_pretty_string(repository_set, request, pool, is_verbose, &installed_map, &self.learned_pool) + problem.get_pretty_string( + repository_set, + request, + pool, + is_verbose, + &installed_map, + &self.learned_pool + ) )); missing_extensions.extend(self.get_extension_problems(problem.get_reasons())); - is_caused_by_lock = is_caused_by_lock || problem.is_caused_by_lock(repository_set, request, pool); + is_caused_by_lock = + is_caused_by_lock || problem.is_caused_by_lock(repository_set, request, pool); } let mut i = 1; @@ -66,7 +74,9 @@ impl SolverProblemsException { } let mut hints: Vec<String> = Vec::new(); - if !is_dev_extraction && (text.contains("could not be found") || text.contains("no matching package found")) { + if !is_dev_extraction + && (text.contains("could not be found") || text.contains("no matching package found")) + { hints.push("Potential causes:\n - A typo in the package name\n - The package is not available in a stable-enough version according to your minimum-stability setting\n see <https://getcomposer.org/doc/04-schema.md#minimum-stability> for more details.\n - It's a private package and you forgot to add a custom repository to find it\n\nRead <https://getcomposer.org/doc/articles/troubleshooting.md> for further common problems.".to_string()); } @@ -74,11 +84,16 @@ impl SolverProblemsException { hints.push(self.create_extension_hint(&missing_extensions)); } - if is_caused_by_lock && !is_dev_extraction && !request.get_update_allow_transitive_root_dependencies() { + if is_caused_by_lock + && !is_dev_extraction + && !request.get_update_allow_transitive_root_dependencies() + { hints.push("Use the option --with-all-dependencies (-W) to allow upgrades, downgrades and removals for packages currently locked to specific versions.".to_string()); } - if text.contains("found composer-plugin-api[2.0.0] but it does not match") && text.contains("- ocramius/package-versions") { + if text.contains("found composer-plugin-api[2.0.0] but it does not match") + && text.contains("- ocramius/package-versions") + { hints.push("<warning>ocramius/package-versions only provides support for Composer 2 in 1.8+, which requires PHP 7.4.</warning>\nIf you can not upgrade PHP you can require <info>composer/package-versions-deprecated</info> to resolve this with PHP 7.0+.".to_string()); } @@ -118,7 +133,9 @@ impl SolverProblemsException { .collect::<Vec<_>>() .join(" "); - let mut text = "To enable extensions, verify that they are enabled in your .ini files:\n - ".to_string(); + let mut text = + "To enable extensions, verify that they are enabled in your .ini files:\n - " + .to_string(); text.push_str(&paths.join("\n - ")); text.push_str("\nYou can also run `php --ini` in a terminal to see which files are used by PHP in CLI mode."); text.push_str(&format!("\nAlternatively, you can run Composer with `{}` to temporarily ignore these required extensions.", ignore_extensions_arguments)); diff --git a/crates/shirabe/src/dependency_resolver/transaction.rs b/crates/shirabe/src/dependency_resolver/transaction.rs index 1b7ed02..7c93114 100644 --- a/crates/shirabe/src/dependency_resolver/transaction.rs +++ b/crates/shirabe/src/dependency_resolver/transaction.rs @@ -4,8 +4,8 @@ use std::any::Any; use indexmap::IndexMap; use shirabe_php_shim::{ - array_filter, array_intersect, array_keys, array_pop, array_unshift, spl_object_hash, strcmp, - uasort, PhpMixed, + PhpMixed, array_filter, array_intersect, array_keys, array_pop, array_unshift, spl_object_hash, + strcmp, uasort, }; use crate::dependency_resolver::operation::install_operation::InstallOperation; @@ -150,9 +150,7 @@ impl Transaction { visited.insert(spl_object_hash(package.as_ref()), true); stack.push(package.clone_box()); - if let Some(alias) = - (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() - { + if let Some(alias) = (package.as_any() as &dyn Any).downcast_ref::<AliasPackage>() { stack.push(alias.get_alias_of().clone_box()); } else { for link in package.get_requires().values() { @@ -170,15 +168,14 @@ impl Transaction { .downcast_ref::<AliasPackage>() .is_some() { - let alias_key = - format!("{}::{}", package.get_name(), package.get_version()); + let alias_key = format!("{}::{}", package.get_name(), package.get_version()); if present_alias_map.contains_key(&alias_key) { remove_alias_map.shift_remove(&alias_key); } else { // TODO(phase-b): MarkAliasInstalledOperation::new expects AliasPackage by value - operations.push(Box::new(MarkAliasInstalledOperation::new( - todo!("package as AliasPackage by value"), - ))); + operations.push(Box::new(MarkAliasInstalledOperation::new(todo!( + "package as AliasPackage by value" + )))); } } else if let Some(source) = present_package_map.get(package.get_name()) { // do we need to update? @@ -187,9 +184,8 @@ impl Transaction { // TODO(phase-b): downcast to CompletePackageInterface trait object let package_is_complete = false; let present_is_complete = false; - let abandoned_or_replacement_changed = package_is_complete - && present_is_complete - && { + let abandoned_or_replacement_changed = + package_is_complete && present_is_complete && { // PHP: $package->isAbandoned() !== $presentPackageMap[$package->getName()]->isAbandoned() // || $package->getReplacementPackage() !== $presentPackageMap[$package->getName()]->getReplacementPackage() todo!("compare abandoned/replacement across CompletePackageInterface") @@ -221,9 +217,9 @@ impl Transaction { } for (_name_version, _package) in remove_alias_map { // TODO(phase-b): MarkAliasUninstalledOperation::new expects AliasPackage by value - operations.push(Box::new(MarkAliasUninstalledOperation::new( - todo!("package as AliasPackage by value"), - ))); + operations.push(Box::new(MarkAliasUninstalledOperation::new(todo!( + "package as AliasPackage by value" + )))); } let operations = self.move_plugins_to_front(operations); @@ -368,9 +364,7 @@ impl Transaction { || package.get_type() == "composer-installer"; // is this a plugin or a dependency of a plugin? - if is_plugin - || array_intersect(&package.get_names(true), &plugin_requires).len() > 0 - { + if is_plugin || array_intersect(&package.get_names(true), &plugin_requires).len() > 0 { // get the package's requires, but filter out any platform requirements let requires: Vec<String> = array_filter( &array_keys(&package.get_requires()), |