refactor: auto-fix clippy warnings

22 files changed, 826 insertions, 909 deletions

diff --git a/crates/shirabe/src/repository/array_repository.rs b/crates/shirabe/src/repository/array_repository.rs
index cfc804f..7f99c1c 100644
--- a/crates/shirabe/src/repository/array_repository.rs
+++ b/crates/shirabe/src/repository/array_repository.rs
@@ -46,13 +46,7 @@ impl ArrayRepository {
             "initialize failed to initialize the packages array"
         );
 
-        self.packages
-            .borrow()
-            .as_ref()
-            .unwrap()
-            .iter()
-            .map(|p| p.clone())
-            .collect()
+        self.packages.borrow().as_ref().unwrap().to_vec()
     }
 
     /// @param array<PackageInterface> $packages
@@ -295,8 +289,8 @@ impl RepositoryInterface for ArrayRepository {
         };
 
         for package in self.get_packages_internal() {
-            if name == package.get_name() {
-                if constraint.is_none()
+            if name == package.get_name()
+                && (constraint.is_none()
                     || constraint.as_ref().unwrap().matches(
                         &SimpleConstraint::new(
                             "==".to_string(),
@@ -304,10 +298,9 @@ impl RepositoryInterface for ArrayRepository {
                             None,
                         )
                         .into(),
-                    )
-                {
-                    packages.push(package);
-                }
+                    ))
+            {
+                packages.push(package);
             }
         }
 
@@ -340,10 +333,10 @@ impl RepositoryInterface for ArrayRepository {
             if matches.contains_key(&name) {
                 continue;
             }
-            if let Some(t) = &r#type {
-                if package.get_type() != *t {
-                    continue;
-                }
+            if let Some(t) = &r#type
+                && package.get_type() != *t
+            {
+                continue;
             }
 
             let complete = package.as_complete();
diff --git a/crates/shirabe/src/repository/composer_repository.rs b/crates/shirabe/src/repository/composer_repository.rs
index 4cc106f..618d375 100644
--- a/crates/shirabe/src/repository/composer_repository.rs
+++ b/crates/shirabe/src/repository/composer_repository.rs
@@ -190,13 +190,12 @@ impl ComposerRepository {
             .into());
         }
 
-        if url_after.starts_with("https?") {
+        if let Some(rest) = url_after.strip_prefix("https?") {
             let scheme = if extension_loaded("openssl") {
                 "https"
             } else {
                 "http"
             };
-            let rest = &url_after[6..];
             repo_config.insert(
                 "url".to_string(),
                 PhpMixed::String(format!("{}{}", scheme, rest)),
@@ -213,7 +212,7 @@ impl ComposerRepository {
         let scheme_present = url_bits_arr
             .and_then(|a| a.get("scheme"))
             .and_then(|v| v.as_string())
-            .map_or(false, |s| !s.is_empty());
+            .is_some_and(|s| !s.is_empty());
         if url_bits_arr.is_none() || !scheme_present {
             return Err(UnexpectedValueException {
                 message: format!("Invalid url given for Composer repository: {}", current_url),
@@ -226,10 +225,10 @@ impl ComposerRepository {
             repo_config.insert("options".to_string(), PhpMixed::Array(IndexMap::new()));
         }
         let mut allow_ssl_downgrade = false;
-        if let Some(v) = repo_config.get("allow_ssl_downgrade") {
-            if v.as_bool() == Some(true) {
-                allow_ssl_downgrade = true;
-            }
+        if let Some(v) = repo_config.get("allow_ssl_downgrade")
+            && v.as_bool() == Some(true)
+        {
+            allow_ssl_downgrade = true;
         }
 
         let options = repo_config
@@ -372,19 +371,17 @@ impl ComposerRepository {
         let has_providers = self.has_providers()?;
 
         if self.lazy_providers_url.is_some() {
-            if let Some(ref available_packages) = self.available_packages.clone() {
-                if self.available_package_patterns.is_none() {
-                    let mut package_map: IndexMap<String, Option<AnyConstraint>> = IndexMap::new();
-                    for name in available_packages.values() {
-                        package_map
-                            .insert(name.clone(), Some(MatchAllConstraint::new(None).into()));
-                    }
+            if let Some(ref available_packages) = self.available_packages.clone()
+                && self.available_package_patterns.is_none()
+            {
+                let mut package_map: IndexMap<String, Option<AnyConstraint>> = IndexMap::new();
+                for name in available_packages.values() {
+                    package_map.insert(name.clone(), Some(MatchAllConstraint::new(None).into()));
+                }
 
-                    let result =
-                        self.load_async_packages(package_map, None, None, IndexMap::new())?;
+                let result = self.load_async_packages(package_map, None, None, IndexMap::new())?;
 
-                    return Ok(result.packages.into_values().collect());
-                }
+                return Ok(result.packages.into_values().collect());
             }
 
             if self.has_partial_packages()? {
@@ -418,7 +415,7 @@ impl ComposerRepository {
             }.into());
         }
 
-        Ok(self.inner.get_packages()?)
+        self.inner.get_packages()
     }
 
     /// @param packageFilter Package pattern filter which can include "*" as a wildcard
@@ -482,21 +479,19 @@ impl ComposerRepository {
     fn get_vendor_names(&mut self) -> anyhow::Result<Vec<String>> {
         let cache_key = "vendor-list.txt";
         let cache_age = self.cache.get_age(cache_key);
-        if let Some(age) = cache_age {
-            if age < 600 {
-                if let Some(cached_data) = self.cache.read(cache_key) {
-                    let cached_data: Vec<String> =
-                        cached_data.split('\n').map(|s| s.to_string()).collect();
-                    return Ok(cached_data);
-                }
-            }
+        if let Some(age) = cache_age
+            && age < 600
+            && let Some(cached_data) = self.cache.read(cache_key)
+        {
+            let cached_data: Vec<String> = cached_data.split('\n').map(|s| s.to_string()).collect();
+            return Ok(cached_data);
         }
 
         let names = self.get_package_names(None)?;
 
         let mut uniques: IndexMap<String, bool> = IndexMap::new();
         for name in &names {
-            let vendor = name.splitn(2, '/').next().unwrap_or("").to_string();
+            let vendor = name.split('/').next().unwrap_or("").to_string();
             uniques.insert(vendor, true);
         }
 
@@ -519,39 +514,37 @@ impl ComposerRepository {
         }
 
         let mut url = self.list_url.clone().unwrap();
-        if let Some(filter) = package_filter {
-            if !filter.is_empty() {
-                url.push_str(&format!("?filter={}", urlencode(filter)));
-                let result = self
-                    .http_downloader
-                    .borrow_mut()
-                    .get(&url, self.options.clone())?
-                    .decode_json()?;
-                let package_names: Vec<String> = result
-                    .as_array()
-                    .and_then(|a| a.get("packageNames"))
-                    .and_then(|v| v.as_list())
-                    .map(|l| {
-                        l.iter()
-                            .filter_map(|v| v.as_string().map(|s| s.to_string()))
-                            .collect()
-                    })
-                    .unwrap_or_default();
+        if let Some(filter) = package_filter
+            && !filter.is_empty()
+        {
+            url.push_str(&format!("?filter={}", urlencode(filter)));
+            let result = self
+                .http_downloader
+                .borrow_mut()
+                .get(&url, self.options.clone())?
+                .decode_json()?;
+            let package_names: Vec<String> = result
+                .as_array()
+                .and_then(|a| a.get("packageNames"))
+                .and_then(|v| v.as_list())
+                .map(|l| {
+                    l.iter()
+                        .filter_map(|v| v.as_string().map(|s| s.to_string()))
+                        .collect()
+                })
+                .unwrap_or_default();
 
-                return Ok(package_names);
-            }
+            return Ok(package_names);
         }
 
         let cache_key = "package-list.txt";
         let cache_age = self.cache.get_age(cache_key);
-        if let Some(age) = cache_age {
-            if age < 600 {
-                if let Some(cached_data) = self.cache.read(cache_key) {
-                    let cached_data: Vec<String> =
-                        cached_data.split('\n').map(|s| s.to_string()).collect();
-                    return Ok(cached_data);
-                }
-            }
+        if let Some(age) = cache_age
+            && age < 600
+            && let Some(cached_data) = self.cache.read(cache_key)
+        {
+            let cached_data: Vec<String> = cached_data.split('\n').map(|s| s.to_string()).collect();
+            return Ok(cached_data);
         }
 
         let result = self
@@ -610,7 +603,7 @@ impl ComposerRepository {
                     && !self
                         .partial_packages_by_name
                         .as_ref()
-                        .map_or(false, |m| m.contains_key(&name))
+                        .is_some_and(|m| m.contains_key(&name))
                 {
                     continue;
                 }
@@ -621,9 +614,7 @@ impl ComposerRepository {
                     Some(&stability_flags),
                     already_loaded.clone(),
                 )?;
-                let constraint = package_name_map
-                    .get(&name)
-                    .and_then(|c| c.as_ref().map(|c| c.clone()));
+                let constraint = package_name_map.get(&name).and_then(|c| c.clone());
                 for (_uid, candidate) in candidates.iter() {
                     if candidate.get_name() != name {
                         return Err(LogicException {
@@ -715,61 +706,61 @@ impl ComposerRepository {
     ) -> anyhow::Result<Vec<IndexMap<String, PhpMixed>>> {
         self.load_root_server_file(Some(600))?;
 
-        if let Some(search_url) = self.search_url.clone() {
-            if mode == SEARCH_FULLTEXT {
-                let url = search_url
-                    .replace("%query%", &urlencode(&query))
-                    .replace("%type%", r#type.as_deref().unwrap_or(""));
+        if let Some(search_url) = self.search_url.clone()
+            && mode == SEARCH_FULLTEXT
+        {
+            let url = search_url
+                .replace("%query%", &urlencode(&query))
+                .replace("%type%", r#type.as_deref().unwrap_or(""));
 
-                let search = self
-                    .http_downloader
-                    .borrow_mut()
-                    .get(&url, self.options.clone())?
-                    .decode_json()?;
+            let search = self
+                .http_downloader
+                .borrow_mut()
+                .get(&url, self.options.clone())?
+                .decode_json()?;
 
-                let results_arr = search
-                    .as_array()
-                    .and_then(|a| a.get("results"))
-                    .and_then(|v| v.as_list())
-                    .cloned()
-                    .unwrap_or_default();
-                if results_arr.is_empty() {
-                    return Ok(vec![]);
-                }
+            let results_arr = search
+                .as_array()
+                .and_then(|a| a.get("results"))
+                .and_then(|v| v.as_list())
+                .cloned()
+                .unwrap_or_default();
+            if results_arr.is_empty() {
+                return Ok(vec![]);
+            }
 
-                let mut results: Vec<IndexMap<String, PhpMixed>> = Vec::new();
-                for result in results_arr.iter() {
-                    let arr = match result.as_array() {
-                        Some(a) => a,
-                        None => continue,
+            let mut results: Vec<IndexMap<String, PhpMixed>> = Vec::new();
+            for result in results_arr.iter() {
+                let arr = match result.as_array() {
+                    Some(a) => a,
+                    None => continue,
+                };
+                // do not show virtual packages in results as they are not directly useful from a composer perspective
+                if let Some(v) = arr.get("virtual") {
+                    // PHP's `empty()` is false when the value is truthy
+                    let is_empty = match &**v {
+                        PhpMixed::Null => true,
+                        PhpMixed::Bool(false) => true,
+                        PhpMixed::Int(0) => true,
+                        PhpMixed::Float(f) if *f == 0.0 => true,
+                        PhpMixed::String(s) if s.is_empty() || s == "0" => true,
+                        PhpMixed::List(l) if l.is_empty() => true,
+                        PhpMixed::Array(a) if a.is_empty() => true,
+                        _ => false,
                     };
-                    // do not show virtual packages in results as they are not directly useful from a composer perspective
-                    if let Some(v) = arr.get("virtual") {
-                        // PHP's `empty()` is false when the value is truthy
-                        let is_empty = match &**v {
-                            PhpMixed::Null => true,
-                            PhpMixed::Bool(false) => true,
-                            PhpMixed::Int(0) => true,
-                            PhpMixed::Float(f) if *f == 0.0 => true,
-                            PhpMixed::String(s) if s.is_empty() || s == "0" => true,
-                            PhpMixed::List(l) if l.is_empty() => true,
-                            PhpMixed::Array(a) if a.is_empty() => true,
-                            _ => false,
-                        };
-                        if !is_empty {
-                            continue;
-                        }
+                    if !is_empty {
+                        continue;
                     }
-
-                    results.push(
-                        arr.iter()
-                            .map(|(k, v)| (k.clone(), (**v).clone()))
-                            .collect(),
-                    );
                 }
 
-                return Ok(results);
+                results.push(
+                    arr.iter()
+                        .map(|(k, v)| (k.clone(), (**v).clone()))
+                        .collect(),
+                );
             }
+
+            return Ok(results);
         }
 
         if mode == SEARCH_VENDOR {
@@ -888,7 +879,7 @@ impl ComposerRepository {
         Ok(self
             .security_advisory_config
             .as_ref()
-            .map_or(false, |c| c.metadata || c.api_url.is_some()))
+            .is_some_and(|c| c.metadata || c.api_url.is_some()))
     }
 
     /// @inheritDoc
@@ -965,7 +956,7 @@ impl ComposerRepository {
         if self
             .security_advisory_config
             .as_ref()
-            .map_or(false, |c| c.metadata)
+            .is_some_and(|c| c.metadata)
             && (allow_partial_advisories || api_url.is_none())
         {
             let names: Vec<String> = package_constraint_map.keys().cloned().collect();
@@ -1019,96 +1010,95 @@ impl ComposerRepository {
             }
         }
 
-        if let Some(api_url) = api_url {
-            if !package_constraint_map.is_empty() {
-                let mut options = self.options.clone();
-                let http_entry = options
-                    .entry("http".to_string())
-                    .or_insert(PhpMixed::Array(IndexMap::new()));
-                if let PhpMixed::Array(http_map) = http_entry {
-                    http_map.insert(
-                        "method".to_string(),
-                        Box::new(PhpMixed::String("POST".to_string())),
-                    );
-                    if let Some(header_box) = http_map.get("header") {
-                        // cast to array
-                        let arr = match &**header_box {
-                            PhpMixed::List(l) => l.clone(),
-                            other => vec![Box::new(other.clone())],
-                        };
-                        http_map.insert("header".to_string(), Box::new(PhpMixed::List(arr)));
-                    }
-                    let mut headers = match http_map.get("header") {
-                        Some(b) => match &**b {
-                            PhpMixed::List(l) => l.clone(),
-                            _ => vec![],
-                        },
-                        None => vec![],
+        if let Some(api_url) = api_url
+            && !package_constraint_map.is_empty()
+        {
+            let mut options = self.options.clone();
+            let http_entry = options
+                .entry("http".to_string())
+                .or_insert(PhpMixed::Array(IndexMap::new()));
+            if let PhpMixed::Array(http_map) = http_entry {
+                http_map.insert(
+                    "method".to_string(),
+                    Box::new(PhpMixed::String("POST".to_string())),
+                );
+                if let Some(header_box) = http_map.get("header") {
+                    // cast to array
+                    let arr = match &**header_box {
+                        PhpMixed::List(l) => l.clone(),
+                        other => vec![Box::new(other.clone())],
                     };
-                    headers.push(Box::new(PhpMixed::String(
-                        "Content-type: application/x-www-form-urlencoded".to_string(),
-                    )));
-                    http_map.insert("header".to_string(), Box::new(PhpMixed::List(headers)));
-                    http_map.insert("timeout".to_string(), Box::new(PhpMixed::Int(10)));
-                    let packages_list: Vec<(String, String)> = package_constraint_map
-                        .keys()
-                        .map(|k| ("packages".to_string(), k.clone()))
-                        .collect();
-                    let body = http_build_query(
-                        &packages_list
-                            .iter()
-                            .map(|(k, v)| (k.as_str(), v.as_str()))
-                            .collect::<Vec<_>>(),
-                        "&",
-                        "=",
-                    );
-                    http_map.insert("content".to_string(), Box::new(PhpMixed::String(body)));
+                    http_map.insert("header".to_string(), Box::new(PhpMixed::List(arr)));
                 }
+                let mut headers = match http_map.get("header") {
+                    Some(b) => match &**b {
+                        PhpMixed::List(l) => l.clone(),
+                        _ => vec![],
+                    },
+                    None => vec![],
+                };
+                headers.push(Box::new(PhpMixed::String(
+                    "Content-type: application/x-www-form-urlencoded".to_string(),
+                )));
+                http_map.insert("header".to_string(), Box::new(PhpMixed::List(headers)));
+                http_map.insert("timeout".to_string(), Box::new(PhpMixed::Int(10)));
+                let packages_list: Vec<(String, String)> = package_constraint_map
+                    .keys()
+                    .map(|k| ("packages".to_string(), k.clone()))
+                    .collect();
+                let body = http_build_query(
+                    &packages_list
+                        .iter()
+                        .map(|(k, v)| (k.as_str(), v.as_str()))
+                        .collect::<Vec<_>>(),
+                    "&",
+                    "=",
+                );
+                http_map.insert("content".to_string(), Box::new(PhpMixed::String(body)));
+            }
 
-                let response = self.http_downloader.borrow_mut().get(&api_url, options)?;
-                let mut warned = false;
-                let decoded = response.decode_json()?;
-                let advisories_response = decoded
-                    .as_array()
-                    .and_then(|a| a.get("advisories"))
-                    .and_then(|v| v.as_array())
-                    .cloned()
-                    .unwrap_or_default();
-                for (name, list_box) in advisories_response.iter() {
-                    if !package_constraint_map.contains_key(name) {
-                        if !warned {
-                            self.io.write_error(&format!(
+            let response = self.http_downloader.borrow_mut().get(&api_url, options)?;
+            let mut warned = false;
+            let decoded = response.decode_json()?;
+            let advisories_response = decoded
+                .as_array()
+                .and_then(|a| a.get("advisories"))
+                .and_then(|v| v.as_array())
+                .cloned()
+                .unwrap_or_default();
+            for (name, list_box) in advisories_response.iter() {
+                if !package_constraint_map.contains_key(name) {
+                    if !warned {
+                        self.io.write_error(&format!(
                                 "<warning>{} returned names which were not requested in response to the security-advisories API. {} was not requested but is present in the response. Requested names were: {}</warning>",
                                 self.get_repo_name(),
                                 name,
                                 package_constraint_map.keys().cloned().collect::<Vec<_>>().join(", "),
                             ));
-                            warned = true;
-                        }
-                        continue;
+                        warned = true;
                     }
-                    let list = match list_box.as_list() {
-                        Some(l) => l.clone(),
-                        None => continue,
-                    };
-                    if !list.is_empty() {
-                        let mut entries: Vec<AnySecurityAdvisory> = Vec::new();
-                        for data_mixed in list.iter() {
-                            if let Some(data) = data_mixed.as_array() {
-                                let data_map: IndexMap<String, PhpMixed> = data
-                                    .iter()
-                                    .map(|(k, v)| (k.clone(), (**v).clone()))
-                                    .collect();
-                                if let Some(adv) = create(&data_map, name, &package_constraint_map)?
-                                {
-                                    entries.push(adv);
-                                }
+                    continue;
+                }
+                let list = match list_box.as_list() {
+                    Some(l) => l.clone(),
+                    None => continue,
+                };
+                if !list.is_empty() {
+                    let mut entries: Vec<AnySecurityAdvisory> = Vec::new();
+                    for data_mixed in list.iter() {
+                        if let Some(data) = data_mixed.as_array() {
+                            let data_map: IndexMap<String, PhpMixed> = data
+                                .iter()
+                                .map(|(k, v)| (k.clone(), (**v).clone()))
+                                .collect();
+                            if let Some(adv) = create(&data_map, name, &package_constraint_map)? {
+                                entries.push(adv);
                             }
                         }
-                        advisories.insert(name.clone(), entries);
                     }
-                    names_found.insert(name.clone(), true);
+                    advisories.insert(name.clone(), entries);
                 }
+                names_found.insert(name.clone(), true);
             }
         }
 
@@ -1137,10 +1127,10 @@ impl ComposerRepository {
             ) {
                 Ok(resp) => resp.decode_json()?,
                 Err(e) => {
-                    if let Some(te) = e.downcast_ref::<TransportException>() {
-                        if te.get_status_code() == Some(404) {
-                            return Ok(result);
-                        }
+                    if let Some(te) = e.downcast_ref::<TransportException>()
+                        && te.get_status_code() == Some(404)
+                    {
+                        return Ok(result);
                     }
                     return Err(e);
                 }
@@ -1152,14 +1142,14 @@ impl ComposerRepository {
                 .and_then(|v| v.as_list())
             {
                 for provider_mixed in providers.iter() {
-                    if let Some(provider) = provider_mixed.as_array() {
-                        if let Some(name) = provider.get("name").and_then(|v| v.as_string()) {
-                            let entry: IndexMap<String, PhpMixed> = provider
-                                .iter()
-                                .map(|(k, v)| (k.clone(), (**v).clone()))
-                                .collect();
-                            result.insert(name.to_string(), entry);
-                        }
+                    if let Some(provider) = provider_mixed.as_array()
+                        && let Some(name) = provider.get("name").and_then(|v| v.as_string())
+                    {
+                        let entry: IndexMap<String, PhpMixed> = provider
+                            .iter()
+                            .map(|(k, v)| (k.clone(), (**v).clone()))
+                            .collect();
+                        result.insert(name.to_string(), entry);
                     }
                 }
             }
@@ -1187,7 +1177,7 @@ impl ComposerRepository {
                         || !candidate
                             .get("provide")
                             .and_then(|v| v.as_array())
-                            .map_or(false, |a| a.contains_key(package_name))
+                            .is_some_and(|a| a.contains_key(package_name))
                     {
                         continue;
                     }
@@ -1291,7 +1281,7 @@ impl ComposerRepository {
             || !self
                 .partial_packages_by_name
                 .as_ref()
-                .map_or(false, |m| m.contains_key(name))
+                .is_some_and(|m| m.contains_key(name))
         {
             // skip platform packages, root package and composer-plugin-api
             if PlatformRepository::is_platform_package(name) || name == "__root__" {
@@ -1314,7 +1304,7 @@ impl ComposerRepository {
                 && !self
                     .provider_listing
                     .as_ref()
-                    .map_or(false, |m| m.contains_key(name))
+                    .is_some_and(|m| m.contains_key(name))
             {
                 hash_opt = None;
                 url = self
@@ -1329,7 +1319,7 @@ impl ComposerRepository {
                 if !self
                     .provider_listing
                     .as_ref()
-                    .map_or(false, |m| m.contains_key(name))
+                    .is_some_and(|m| m.contains_key(name))
                 {
                     return Ok(IndexMap::new());
                 }
@@ -1365,13 +1355,33 @@ impl ComposerRepository {
                         ));
                     }
                 }
-            } else if use_last_modified_check {
-                if let Some(contents_raw) = self.cache.read(&cache_key) {
-                    let contents = json_decode(&contents_raw, true)?;
-                    let contents_arr = contents.as_array().cloned();
-                    // we already loaded some packages from this file, so assume it is fresh and avoid fetching it again
-                    if already_loaded.contains_key(name) {
-                        if let Some(arr) = &contents_arr {
+            } else if use_last_modified_check
+                && let Some(contents_raw) = self.cache.read(&cache_key)
+            {
+                let contents = json_decode(&contents_raw, true)?;
+                let contents_arr = contents.as_array().cloned();
+                // we already loaded some packages from this file, so assume it is fresh and avoid fetching it again
+                if already_loaded.contains_key(name) {
+                    if let Some(arr) = &contents_arr {
+                        let map: IndexMap<String, PhpMixed> = arr
+                            .iter()
+                            .map(|(k, v)| (k.clone(), (**v).clone()))
+                            .collect();
+                        packages_opt = Some(map);
+                        packages_source = Some(format!(
+                            "cached file ({} originating from {})",
+                            cache_key,
+                            Url::sanitize(url.clone())
+                        ));
+                    }
+                } else if let Some(arr) = &contents_arr
+                    && let Some(last_modified) =
+                        arr.get("last-modified").and_then(|v| v.as_string())
+                {
+                    let response =
+                        self.fetch_file_if_last_modified(&url, &cache_key, last_modified)?;
+                    match response {
+                        FetchFileIfLastModifiedResult::NotModified => {
                             let map: IndexMap<String, PhpMixed> = arr
                                 .iter()
                                 .map(|(k, v)| (k.clone(), (**v).clone()))
@@ -1383,33 +1393,10 @@ impl ComposerRepository {
                                 Url::sanitize(url.clone())
                             ));
                         }
-                    } else if let Some(arr) = &contents_arr {
-                        if let Some(last_modified) =
-                            arr.get("last-modified").and_then(|v| v.as_string())
-                        {
-                            let response =
-                                self.fetch_file_if_last_modified(&url, &cache_key, last_modified)?;
-                            match response {
-                                FetchFileIfLastModifiedResult::NotModified => {
-                                    let map: IndexMap<String, PhpMixed> = arr
-                                        .iter()
-                                        .map(|(k, v)| (k.clone(), (**v).clone()))
-                                        .collect();
-                                    packages_opt = Some(map);
-                                    packages_source = Some(format!(
-                                        "cached file ({} originating from {})",
-                                        cache_key,
-                                        Url::sanitize(url.clone())
-                                    ));
-                                }
-                                FetchFileIfLastModifiedResult::Data(data) => {
-                                    packages_opt = Some(data);
-                                    packages_source = Some(format!(
-                                        "downloaded file ({})",
-                                        Url::sanitize(url.clone())
-                                    ));
-                                }
-                            }
+                        FetchFileIfLastModifiedResult::Data(data) => {
+                            packages_opt = Some(data);
+                            packages_source =
+                                Some(format!("downloaded file ({})", Url::sanitize(url.clone())));
                         }
                     }
                 }
@@ -1545,7 +1532,7 @@ impl ComposerRepository {
                     && self
                         .partial_packages_by_name
                         .as_ref()
-                        .map_or(false, |m| m.contains_key(&normalized_name))
+                        .is_some_and(|m| m.contains_key(&normalized_name))
                 {
                     continue;
                 }
@@ -1572,7 +1559,7 @@ impl ComposerRepository {
                     } else if version
                         .get("version_normalized")
                         .and_then(|v| v.as_string())
-                        .map_or(false, |s| s == VersionParser::DEFAULT_BRANCH_ALIAS)
+                        == Some(VersionParser::DEFAULT_BRANCH_ALIAS)
                     {
                         // handling of existing repos which need to remain composer v1 compatible, in case the version_normalized contained VersionParser::DEFAULT_BRANCH_ALIAS, we renormalize it
                         let v = version
@@ -1595,7 +1582,7 @@ impl ComposerRepository {
                     // avoid loading packages which have already been loaded
                     if already_loaded
                         .get(name)
-                        .map_or(false, |m| m.contains_key(&version_normalized))
+                        .is_some_and(|m| m.contains_key(&version_normalized))
                     {
                         continue;
                     }
@@ -1661,7 +1648,7 @@ impl ComposerRepository {
     /// Adds a new package to the repository
     pub fn add_package(&mut self, package: BasePackageHandle) {
         self.configure_package_transport_options(package.clone());
-        self.inner.add_package(package.into());
+        self.inner.add_package(package);
     }
 
     /// Forwards the outermost handle's weak to the inner `ArrayRepository` so that packages added
@@ -1705,9 +1692,7 @@ impl ComposerRepository {
         // load ~dev versions of the packages as well if needed
         let names_snapshot: Vec<String> = package_names.keys().cloned().collect();
         for name in names_snapshot {
-            let constraint = package_names
-                .get(&name)
-                .and_then(|c| c.as_ref().map(|c| c.clone()));
+            let constraint = package_names.get(&name).and_then(|c| c.clone());
             if acceptable_stabilities.is_none()
                 || stability_flags.is_none()
                 || StabilityFilter::is_package_acceptable(
@@ -1720,8 +1705,8 @@ impl ComposerRepository {
                 package_names.insert(format!("{}~dev", name), constraint);
             }
             // if only dev stability is requested, we skip loading the non dev file
-            if acceptable_stabilities.map_or(false, |m| m.contains_key("dev") && m.len() == 1)
-                && stability_flags.map_or(false, |m| m.is_empty())
+            if acceptable_stabilities.is_some_and(|m| m.contains_key("dev") && m.len() == 1)
+                && stability_flags.is_some_and(|m| m.is_empty())
             {
                 package_names.shift_remove(&name);
             }
@@ -1801,10 +1786,8 @@ impl ComposerRepository {
                 _ => continue,
             };
 
-            let minified = response_arr
-                .get("minified")
-                .and_then(|v| v.as_string())
-                .map_or(false, |s| s == "composer/2.0");
+            let minified =
+                response_arr.get("minified").and_then(|v| v.as_string()) == Some("composer/2.0");
             if minified {
                 versions = MetadataMinifier::expand(versions);
             }
@@ -1828,7 +1811,7 @@ impl ComposerRepository {
                 } else if version
                     .get("version_normalized")
                     .and_then(|v| v.as_string())
-                    .map_or(false, |s| s == VersionParser::DEFAULT_BRANCH_ALIAS)
+                    == Some(VersionParser::DEFAULT_BRANCH_ALIAS)
                 {
                     // handling of existing repos which need to remain composer v1 compatible, in case the version_normalized contained VersionParser::DEFAULT_BRANCH_ALIAS, we renormalize it
                     let v = version
@@ -1851,7 +1834,7 @@ impl ComposerRepository {
                 // avoid loading packages which have already been loaded
                 if already_loaded
                     .get(&real_name)
-                    .map_or(false, |m| m.contains_key(&version_normalized))
+                    .is_some_and(|m| m.contains_key(&version_normalized))
                 {
                     continue;
                 }
@@ -1966,8 +1949,8 @@ impl ComposerRepository {
         let has_pkg = response_arr
             .and_then(|a| a.get("packages"))
             .and_then(|v| v.as_array())
-            .map_or(false, |a| a.contains_key(&package_name));
-        let has_advisories = response_arr.map_or(false, |a| a.contains_key("security-advisories"));
+            .is_some_and(|a| a.contains_key(&package_name));
+        let has_advisories = response_arr.is_some_and(|a| a.contains_key("security-advisories"));
         if !has_pkg && !has_advisories {
             return Ok(PhpMixed::List(vec![
                 Box::new(PhpMixed::Null),
@@ -2050,10 +2033,10 @@ impl ComposerRepository {
                 continue;
             }
 
-            if let Some(c) = constraint {
-                if !CompilingMatcher::r#match(c, SimpleConstraint::OP_EQ, version.clone()) {
-                    continue;
-                }
+            if let Some(c) = constraint
+                && !CompilingMatcher::r#match(c, SimpleConstraint::OP_EQ, version.clone())
+            {
+                continue;
             }
 
             return Ok(true);
@@ -2069,7 +2052,7 @@ impl ComposerRepository {
             .as_array()
             .and_then(|a| a.get("path"))
             .and_then(|v| v.as_string())
-            .map_or(false, |p| p.contains(".json"));
+            .is_some_and(|p| p.contains(".json"));
         if has_json {
             return self.url.clone();
         }
@@ -2177,7 +2160,7 @@ impl ComposerRepository {
                     self.source_mirrors
                         .get_or_insert_with(IndexMap::new)
                         .entry("git".to_string())
-                        .or_insert_with(Vec::new)
+                        .or_default()
                         .push(SourceMirror {
                             url: git_url,
                             preferred,
@@ -2196,7 +2179,7 @@ impl ComposerRepository {
                     self.source_mirrors
                         .get_or_insert_with(IndexMap::new)
                         .entry("hg".to_string())
-                        .or_insert_with(Vec::new)
+                        .or_default()
                         .push(SourceMirror {
                             url: hg_url,
                             preferred,
@@ -2268,19 +2251,18 @@ impl ComposerRepository {
                 .get("available-packages")
                 .and_then(|v| v.as_list())
                 .cloned()
+                && !available.is_empty()
             {
-                if !available.is_empty() {
-                    let avail_packages: Vec<String> = available
-                        .iter()
-                        .filter_map(|v| v.as_string().map(|s| strtolower(s)))
-                        .collect();
-                    let mut combined: IndexMap<String, String> = IndexMap::new();
-                    for k in avail_packages.iter() {
-                        combined.insert(k.clone(), k.clone());
-                    }
-                    self.available_packages = Some(combined);
-                    self.has_available_package_list = true;
+                let avail_packages: Vec<String> = available
+                    .iter()
+                    .filter_map(|v| v.as_string().map(strtolower))
+                    .collect();
+                let mut combined: IndexMap<String, String> = IndexMap::new();
+                for k in avail_packages.iter() {
+                    combined.insert(k.clone(), k.clone());
                 }
+                self.available_packages = Some(combined);
+                self.has_available_package_list = true;
             }
 
             // Provides a list of package name patterns (using * wildcards to match any substring, e.g. "vendor/*") that are available in this repo
@@ -2290,16 +2272,15 @@ impl ComposerRepository {
                 .get("available-package-patterns")
                 .and_then(|v| v.as_list())
                 .cloned()
+                && !patterns.is_empty()
             {
-                if !patterns.is_empty() {
-                    let mapped: Vec<String> = patterns
-                        .iter()
-                        .filter_map(|v| v.as_string())
-                        .map(|p| base_package::package_name_to_regexp(p))
-                        .collect();
-                    self.available_package_patterns = Some(mapped);
-                    self.has_available_package_list = true;
-                }
+                let mapped: Vec<String> = patterns
+                    .iter()
+                    .filter_map(|v| v.as_string())
+                    .map(base_package::package_name_to_regexp)
+                    .collect();
+                self.available_package_patterns = Some(mapped);
+                self.has_available_package_list = true;
             }
 
             // Remove legacy keys as most repos need to be compatible with Composer v1
@@ -2459,53 +2440,50 @@ impl ComposerRepository {
             }
             let listing = self.provider_listing.as_mut().unwrap();
             for (k, v) in providers.iter() {
-                if let Some(arr) = v.as_array() {
-                    if let Some(sha256) = arr.get("sha256").and_then(|v| v.as_string()) {
-                        listing.insert(
-                            k.clone(),
-                            ProviderListingEntry {
-                                sha256: sha256.to_string(),
-                            },
-                        );
-                    }
+                if let Some(arr) = v.as_array()
+                    && let Some(sha256) = arr.get("sha256").and_then(|v| v.as_string())
+                {
+                    listing.insert(
+                        k.clone(),
+                        ProviderListingEntry {
+                            sha256: sha256.to_string(),
+                        },
+                    );
                 }
             }
         }
 
-        if self.providers_url.is_some() {
-            if let Some(includes) = data
+        if self.providers_url.is_some()
+            && let Some(includes) = data
                 .get("provider-includes")
                 .and_then(|v| v.as_array())
                 .cloned()
-            {
-                for (include, metadata_mixed) in includes.iter() {
-                    let metadata = match metadata_mixed.as_array() {
-                        Some(a) => a,
-                        None => continue,
+        {
+            for (include, metadata_mixed) in includes.iter() {
+                let metadata = match metadata_mixed.as_array() {
+                    Some(a) => a,
+                    None => continue,
+                };
+                let sha256 = metadata
+                    .get("sha256")
+                    .and_then(|v| v.as_string())
+                    .unwrap_or("")
+                    .to_string();
+                let url = format!("{}/{}", self.base_url, include.replace("%hash%", &sha256));
+                let cache_key = include.replace("%hash%", "").replace("$", "");
+                let included_data: IndexMap<String, PhpMixed> =
+                    if self.cache.sha256(&cache_key).as_deref() == Some(sha256.as_str()) {
+                        let raw = self.cache.read(&cache_key).unwrap_or_default();
+                        let decoded = json_decode(&raw, true)?;
+                        decoded
+                            .as_array()
+                            .map(|a| a.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect())
+                            .unwrap_or_default()
+                    } else {
+                        self.fetch_file(&url, Some(&cache_key), Some(&sha256), false)?
                     };
-                    let sha256 = metadata
-                        .get("sha256")
-                        .and_then(|v| v.as_string())
-                        .unwrap_or("")
-                        .to_string();
-                    let url = format!("{}/{}", self.base_url, include.replace("%hash%", &sha256));
-                    let cache_key = include.replace("%hash%", "").replace("$", "");
-                    let included_data: IndexMap<String, PhpMixed> =
-                        if self.cache.sha256(&cache_key).as_deref() == Some(sha256.as_str()) {
-                            let raw = self.cache.read(&cache_key).unwrap_or_default();
-                            let decoded = json_decode(&raw, true)?;
-                            decoded
-                                .as_array()
-                                .map(|a| {
-                                    a.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect()
-                                })
-                                .unwrap_or_default()
-                        } else {
-                            self.fetch_file(&url, Some(&cache_key), Some(&sha256), false)?
-                        };
 
-                    self.load_provider_listings(&included_data)?;
-                }
+                self.load_provider_listings(&included_data)?;
             }
         }
         Ok(())
@@ -2633,19 +2611,18 @@ impl ComposerRepository {
 
             let mut results: Vec<BasePackageHandle> = Vec::new();
             for package in package_instances.into_iter() {
-                if let Some(src_type) = package.get_source_type() {
-                    if let Some(mirrors) =
+                if let Some(src_type) = package.get_source_type()
+                    && let Some(mirrors) =
                         self.source_mirrors.as_ref().and_then(|m| m.get(&src_type))
-                    {
-                        let converted: Vec<crate::package::Mirror> = mirrors
-                            .iter()
-                            .map(|m| crate::package::Mirror {
-                                url: m.url.clone(),
-                                preferred: m.preferred,
-                            })
-                            .collect();
-                        package.set_source_mirrors(Some(converted));
-                    }
+                {
+                    let converted: Vec<crate::package::Mirror> = mirrors
+                        .iter()
+                        .map(|m| crate::package::Mirror {
+                            url: m.url.clone(),
+                            preferred: m.preferred,
+                        })
+                        .collect();
+                    package.set_source_mirrors(Some(converted));
                 }
                 if let Some(dist_mirrors) = self.dist_mirrors.as_ref() {
                     let converted: Vec<crate::package::Mirror> = dist_mirrors
@@ -2658,7 +2635,7 @@ impl ComposerRepository {
                     package.set_dist_mirrors(Some(converted));
                 }
                 self.configure_package_transport_options(package.clone());
-                results.push(package.into());
+                results.push(package);
             }
             Ok(results)
         })();
@@ -2673,7 +2650,7 @@ impl ComposerRepository {
                         .map(|s| format!(" from {}", s))
                         .unwrap_or_default(),
                     "Exception",
-                    e.to_string()
+                    e
                 ),
                 code: 0,
             }
@@ -2689,11 +2666,7 @@ impl ComposerRepository {
             return Ok(vec![]);
         }
         let loader = ArrayLoader::new(Some(VersionParser::new()), true);
-        Ok(loader
-            .load_packages(packages)?
-            .into_iter()
-            .map(|p| p.into())
-            .collect())
+        Ok(loader.load_packages(packages)?.into_iter().collect())
     }
 
     fn fetch_file(
@@ -2721,10 +2694,11 @@ impl ComposerRepository {
         };
 
         // url-encode $ signs in URLs as bad proxies choke on them
-        if let Some(pos) = filename.find('$') {
-            if pos > 0 && Preg::is_match(r"{^https?://}i", &filename) {
-                filename = format!("{}%24{}", &filename[..pos], &filename[pos + 1..]);
-            }
+        if let Some(pos) = filename.find('$')
+            && pos > 0
+            && Preg::is_match(r"{^https?://}i", &filename)
+        {
+            filename = format!("{}%24{}", &filename[..pos], &filename[pos + 1..]);
         }
 
         let mut retries: i64 = 3;
@@ -2776,29 +2750,29 @@ impl ComposerRepository {
                     .borrow_mut()
                     .get(&filename, options.clone())?;
                 let mut json = response.get_body().unwrap_or("").to_string();
-                if let Some(sha256_val) = sha256 {
-                    if sha256_val != hash("sha256", &json) {
-                        // undo downgrade before trying again if http seems to be hijacked or modifying content somehow
-                        if self.allow_ssl_downgrade {
-                            self.url = self.url.replace("http://", "https://");
-                            self.base_url = self.base_url.replace("http://", "https://");
-                            filename = filename.replace("http://", "https://");
-                        }
+                if let Some(sha256_val) = sha256
+                    && sha256_val != hash("sha256", &json)
+                {
+                    // undo downgrade before trying again if http seems to be hijacked or modifying content somehow
+                    if self.allow_ssl_downgrade {
+                        self.url = self.url.replace("http://", "https://");
+                        self.base_url = self.base_url.replace("http://", "https://");
+                        filename = filename.replace("http://", "https://");
+                    }
 
-                        if retries > 0 {
-                            std::thread::sleep(std::time::Duration::from_micros(100000));
-                            return Err(RetryMarker.into());
-                        }
+                    if retries > 0 {
+                        std::thread::sleep(std::time::Duration::from_micros(100000));
+                        return Err(RetryMarker.into());
+                    }
 
-                        // TODO use scarier wording once we know for sure it doesn't do false positives anymore
-                        return Err(RepositorySecurityException(shirabe_php_shim::Exception {
+                    // TODO use scarier wording once we know for sure it doesn't do false positives anymore
+                    return Err(RepositorySecurityException(shirabe_php_shim::Exception {
                             message: format!(
                                 "The contents of {} do not match its signature. This could indicate a man-in-the-middle attack or e.g. antivirus software corrupting files. Try running composer again and report this if you think it is a mistake.",
                                 filename
                             ),
                             code: 0,
                         }).into());
-                    }
                 }
 
                 if let Some(dispatcher) = self.event_dispatcher.as_ref() {
@@ -2832,28 +2806,26 @@ impl ComposerRepository {
                     .unwrap_or_default();
                 HttpDownloader::output_warnings(self.io.clone(), &self.url, &data_local);
 
-                if let Some(ck) = cache_key_owned.as_ref() {
-                    if !ck.is_empty() && !self.cache.is_read_only() {
-                        if store_last_modified_time {
-                            if let Some(last_modified_date) = response.get_header("last-modified") {
-                                data_local.insert(
-                                    "last-modified".to_string(),
-                                    PhpMixed::String(last_modified_date),
-                                );
-                                let as_mixed = PhpMixed::Array(
-                                    data_local
-                                        .iter()
-                                        .map(|(k, v)| (k.clone(), Box::new(v.clone())))
-                                        .collect(),
-                                );
-                                json = JsonFile::encode_with_options(
-                                    &as_mixed,
-                                    JsonEncodeOptions::none(),
-                                );
-                            }
-                        }
-                        self.cache.write(ck, &json);
+                if let Some(ck) = cache_key_owned.as_ref()
+                    && !ck.is_empty()
+                    && !self.cache.is_read_only()
+                {
+                    if store_last_modified_time
+                        && let Some(last_modified_date) = response.get_header("last-modified")
+                    {
+                        data_local.insert(
+                            "last-modified".to_string(),
+                            PhpMixed::String(last_modified_date),
+                        );
+                        let as_mixed = PhpMixed::Array(
+                            data_local
+                                .iter()
+                                .map(|(k, v)| (k.clone(), Box::new(v.clone())))
+                                .collect(),
+                        );
+                        json = JsonFile::encode_with_options(&as_mixed, JsonEncodeOptions::none());
                     }
+                    self.cache.write(ck, &json);
                 }
 
                 response.collect();
@@ -2871,41 +2843,38 @@ impl ComposerRepository {
                     if e.downcast_ref::<LogicException>().is_some() {
                         return Err(e);
                     }
-                    if let Some(te) = e.downcast_ref::<TransportException>() {
-                        if te.get_status_code() == Some(404) {
-                            return Err(e);
-                        }
+                    if let Some(te) = e.downcast_ref::<TransportException>()
+                        && te.get_status_code() == Some(404)
+                    {
+                        return Err(e);
                     }
                     if e.downcast_ref::<RepositorySecurityException>().is_some() {
                         return Err(e);
                     }
 
-                    if let Some(ck) = cache_key_owned.as_ref() {
-                        if !ck.is_empty() {
-                            if let Some(contents) = self.cache.read(ck) {
-                                if !self.degraded_mode {
-                                    self.io.write_error(&format!(
+                    if let Some(ck) = cache_key_owned.as_ref()
+                        && !ck.is_empty()
+                        && let Some(contents) = self.cache.read(ck)
+                    {
+                        if !self.degraded_mode {
+                            self.io.write_error(&format!(
                                         "<warning>{} could not be fully loaded ({}), package information was loaded from the local cache and may be out of date</warning>",
                                         self.url,
-                                        e.to_string()
+                                        e
                                     ));
-                                }
-                                self.degraded_mode = true;
-                                let parsed = JsonFile::parse_json(
-                                    Some(&contents),
-                                    Some(&format!("{}{}", self.cache.get_root(), ck)),
-                                )?;
-                                let map: IndexMap<String, PhpMixed> = parsed
-                                    .as_array()
-                                    .map(|a| {
-                                        a.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect()
-                                    })
-                                    .unwrap_or_default();
-                                data = Some(map);
-
-                                break;
-                            }
                         }
+                        self.degraded_mode = true;
+                        let parsed = JsonFile::parse_json(
+                            Some(&contents),
+                            Some(&format!("{}{}", self.cache.get_root(), ck)),
+                        )?;
+                        let map: IndexMap<String, PhpMixed> = parsed
+                            .as_array()
+                            .map(|a| a.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect())
+                            .unwrap_or_default();
+                        data = Some(map);
+
+                        break;
                     }
 
                     return Err(e);
@@ -3060,17 +3029,17 @@ impl ComposerRepository {
                 if e.downcast_ref::<LogicException>().is_some() {
                     return Err(e);
                 }
-                if let Some(te) = e.downcast_ref::<TransportException>() {
-                    if te.get_status_code() == Some(404) {
-                        return Err(e);
-                    }
+                if let Some(te) = e.downcast_ref::<TransportException>()
+                    && te.get_status_code() == Some(404)
+                {
+                    return Err(e);
                 }
 
                 if !self.degraded_mode {
                     self.io.write_error(&format!(
                         "<warning>{} could not be fully loaded ({}), package information was loaded from the local cache and may be out of date</warning>",
                         self.url,
-                        e.to_string()
+                        e
                     ));
                 }
                 self.degraded_mode = true;
@@ -3252,13 +3221,13 @@ impl ComposerRepository {
         cache_key: &str,
         last_modified_time: Option<&str>,
     ) -> anyhow::Result<PhpMixed> {
-        if let Some(te) = e.downcast_ref::<TransportException>() {
-            if te.get_status_code() == Some(404) {
-                self.packages_not_found_cache
-                    .insert(filename.to_string(), true);
+        if let Some(te) = e.downcast_ref::<TransportException>()
+            && te.get_status_code() == Some(404)
+        {
+            self.packages_not_found_cache
+                .insert(filename.to_string(), true);
 
-                return Ok(PhpMixed::Bool(false));
-            }
+            return Ok(PhpMixed::Bool(false));
         }
 
         if !self.degraded_mode {
@@ -3277,12 +3246,11 @@ impl ComposerRepository {
         }
 
         // special error code returned when network is being artificially disabled
-        if let Some(te) = e.downcast_ref::<TransportException>() {
-            if te.get_status_code() == Some(499) {
-                let resp =
-                    Response::new(self.url.clone(), Some(404), Vec::new(), Some(String::new()));
-                return self.async_fetch_file_accept(resp, filename, cache_key);
-            }
+        if let Some(te) = e.downcast_ref::<TransportException>()
+            && te.get_status_code() == Some(499)
+        {
+            let resp = Response::new(self.url.clone(), Some(404), Vec::new(), Some(String::new()));
+            return self.async_fetch_file_accept(resp, filename, cache_key);
         }
 
         Err(e)
@@ -3328,7 +3296,7 @@ impl ComposerRepository {
                         .as_mut()
                         .unwrap()
                         .entry(version_package_name.clone())
-                        .or_insert_with(Vec::new)
+                        .or_default()
                         .push(version_map);
                     if !self.displayed_warning_about_non_matching_package_index
                         && version_package_name != strtolower(package)
@@ -3359,10 +3327,10 @@ impl ComposerRepository {
             }.into());
         }
 
-        if let Some(ref available) = self.available_packages {
-            if available.contains_key(name) {
-                return Ok(true);
-            }
+        if let Some(ref available) = self.available_packages
+            && available.contains_key(name)
+        {
+            return Ok(true);
         }
 
         if let Some(ref patterns) = self.available_package_patterns {
@@ -3432,7 +3400,7 @@ impl RepositoryInterface for ComposerRepository {
                 && self
                     .partial_packages_by_name
                     .as_ref()
-                    .map_or(false, |m| m.contains_key(&name))
+                    .is_some_and(|m| m.contains_key(&name))
             {
                 let packages = self.what_provides(&name, None, None, IndexMap::new())?;
                 let packages_vec: Vec<BasePackageHandle> = packages.into_values().collect();
@@ -3506,7 +3474,7 @@ impl RepositoryInterface for ComposerRepository {
                 && self
                     .partial_packages_by_name
                     .as_ref()
-                    .map_or(false, |m| m.contains_key(&name))
+                    .is_some_and(|m| m.contains_key(&name))
             {
                 let packages = self.what_provides(&name, None, None, IndexMap::new())?;
                 let packages_vec: Vec<BasePackageHandle> = packages.into_values().collect();
diff --git a/crates/shirabe/src/repository/composite_repository.rs b/crates/shirabe/src/repository/composite_repository.rs
index dafedfc..27e6bf2 100644
--- a/crates/shirabe/src/repository/composite_repository.rs
+++ b/crates/shirabe/src/repository/composite_repository.rs
@@ -137,7 +137,7 @@ impl RepositoryInterface for CompositeRepository {
         for repository in &self.repositories {
             let name_map_cloned: IndexMap<String, Option<AnyConstraint>> = package_name_map
                 .iter()
-                .map(|(k, v)| (k.clone(), v.as_ref().map(|c| c.clone())))
+                .map(|(k, v)| (k.clone(), v.clone()))
                 .collect();
             let result = repository.load_packages(
                 name_map_cloned,
diff --git a/crates/shirabe/src/repository/filesystem_repository.rs b/crates/shirabe/src/repository/filesystem_repository.rs
index 38d5836..79136c9 100644
--- a/crates/shirabe/src/repository/filesystem_repository.rs
+++ b/crates/shirabe/src/repository/filesystem_repository.rs
@@ -253,28 +253,28 @@ impl FilesystemRepository {
             let mut pkg_array = dumper.dump(package.clone());
             let path = installation_manager.get_install_path(package.clone());
             let mut install_path: Option<String> = None;
-            if let Some(path_str) = &path {
-                if !path_str.is_empty() {
-                    let normalized_path = self.filesystem.borrow_mut().normalize_path(&if self
-                        .filesystem
-                        .borrow()
-                        .is_absolute_path(path_str)
-                    {
-                        path_str.clone()
-                    } else {
-                        format!(
-                            "{}/{}",
-                            Platform::get_cwd(false).unwrap_or_default(),
-                            path_str
-                        )
-                    });
-                    install_path = Some(self.filesystem.borrow_mut().find_shortest_path(
-                        &repo_dir,
-                        &normalized_path,
-                        true,
-                        false,
-                    ));
-                }
+            if let Some(path_str) = &path
+                && !path_str.is_empty()
+            {
+                let normalized_path = self.filesystem.borrow_mut().normalize_path(&if self
+                    .filesystem
+                    .borrow()
+                    .is_absolute_path(path_str)
+                {
+                    path_str.clone()
+                } else {
+                    format!(
+                        "{}/{}",
+                        Platform::get_cwd(false).unwrap_or_default(),
+                        path_str
+                    )
+                });
+                install_path = Some(self.filesystem.borrow_mut().find_shortest_path(
+                    &repo_dir,
+                    &normalized_path,
+                    true,
+                    false,
+                ));
             }
             install_paths.insert(package.get_name().to_string(), install_path.clone());
 
@@ -306,10 +306,9 @@ impl FilesystemRepository {
                         .collect(),
                 ),
                 true,
-            ) {
-                if let Some(PhpMixed::List(list)) = data.get_mut("dev-package-names") {
-                    list.push(Box::new(PhpMixed::String(package.get_name().to_string())));
-                }
+            ) && let Some(PhpMixed::List(list)) = data.get_mut("dev-package-names")
+            {
+                list.push(Box::new(PhpMixed::String(package.get_name().to_string())));
             }
         }
 
@@ -497,12 +496,8 @@ impl FilesystemRepository {
                 .map(|s| Box::new(PhpMixed::String(s.clone())))
                 .collect(),
         ));
-        let mut packages: Vec<PackageInterfaceHandle> = self
-            .inner
-            .get_packages()?
-            .into_iter()
-            .map(|p| p.into())
-            .collect();
+        let mut packages: Vec<PackageInterfaceHandle> =
+            self.inner.get_packages()?.into_iter().collect();
         let mut current_root: RootPackageInterfaceHandle = match &self.root_package {
             None => {
                 return Err(LogicException {
@@ -617,10 +612,10 @@ impl FilesystemRepository {
                 "aliases",
                 pretty.clone(),
             );
-            if package.as_root().is_some() {
-                if let Some(PhpMixed::Array(root_map)) = versions.get_mut("root") {
-                    push_to_list(root_map, "aliases", pretty);
-                }
+            if package.as_root().is_some()
+                && let Some(PhpMixed::Array(root_map)) = versions.get_mut("root")
+            {
+                push_to_list(root_map, "aliases", pretty);
             }
         }
 
@@ -633,16 +628,16 @@ impl FilesystemRepository {
             for (_name, version) in versions_map.iter_mut() {
                 if let PhpMixed::Array(version_map) = version.as_mut() {
                     for key in ["aliases", "replaced", "provided"] {
-                        if let Some(boxed) = version_map.get_mut(key) {
-                            if let PhpMixed::List(list) = boxed.as_mut() {
-                                // PHP: sort($versions['versions'][$name][$key], SORT_NATURAL);
-                                usort(list, |a: &Box<PhpMixed>, b: &Box<PhpMixed>| -> i64 {
-                                    shirabe_php_shim::strnatcmp(
-                                        a.as_string().unwrap_or(""),
-                                        b.as_string().unwrap_or(""),
-                                    )
-                                });
-                            }
+                        if let Some(boxed) = version_map.get_mut(key)
+                            && let PhpMixed::List(list) = boxed.as_mut()
+                        {
+                            // PHP: sort($versions['versions'][$name][$key], SORT_NATURAL);
+                            usort(list, |a: &Box<PhpMixed>, b: &Box<PhpMixed>| -> i64 {
+                                shirabe_php_shim::strnatcmp(
+                                    a.as_string().unwrap_or(""),
+                                    b.as_string().unwrap_or(""),
+                                )
+                            });
                         }
                     }
                 }
@@ -665,9 +660,9 @@ impl FilesystemRepository {
         let mut reference: Option<String> = None;
         if let Some(install_src) = package.get_installation_source() {
             reference = if install_src == "source" {
-                package.get_source_reference().map(String::from)
+                package.get_source_reference()
             } else {
-                package.get_dist_reference().map(String::from)
+                package.get_dist_reference()
             };
         }
         if reference.is_none() {
diff --git a/crates/shirabe/src/repository/handle.rs b/crates/shirabe/src/repository/handle.rs
index 6721bb2..2e83ef8 100644
--- a/crates/shirabe/src/repository/handle.rs
+++ b/crates/shirabe/src/repository/handle.rs
@@ -152,7 +152,7 @@ impl RepositoryInterfaceHandle {
         self.0
             .borrow()
             .as_installed_repository_interface()
-            .map_or(false, |r| r.is_fresh())
+            .is_some_and(|r| r.is_fresh())
     }
 
     pub fn get_dev_mode(&self) -> Option<bool> {
diff --git a/crates/shirabe/src/repository/installed_repository.rs b/crates/shirabe/src/repository/installed_repository.rs
index f6b9643..55ec50f 100644
--- a/crates/shirabe/src/repository/installed_repository.rs
+++ b/crates/shirabe/src/repository/installed_repository.rs
@@ -140,37 +140,32 @@ impl InstalledRepository {
                 let needles_snapshot = needles.clone();
                 for link in package.get_replaces().values() {
                     for needle in &needles_snapshot {
-                        if link.get_source() == needle.as_str() {
-                            if constraint.is_none()
-                                || link.get_constraint().matches(constraint.as_ref().unwrap())
-                            {
-                                if packages_in_tree.contains(&link.get_target().to_string()) {
-                                    results.push(DependentsEntry(
-                                        package.clone(),
-                                        link.clone(),
-                                        None,
-                                    ));
-                                    continue;
-                                }
-                                packages_in_tree.push(link.get_target().to_string());
-                                let dependents = if recurse {
-                                    self.get_dependents(
-                                        NeedleInput::Single(link.get_target().to_string()),
-                                        None,
-                                        false,
-                                        true,
-                                        Some(packages_in_tree.clone()),
-                                    )?
-                                } else {
-                                    vec![]
-                                };
-                                results.push(DependentsEntry(
-                                    package.clone(),
-                                    link.clone(),
-                                    Some(dependents),
-                                ));
-                                needles.push(link.get_target().to_string());
+                        if link.get_source() == needle.as_str()
+                            && (constraint.is_none()
+                                || link.get_constraint().matches(constraint.as_ref().unwrap()))
+                        {
+                            if packages_in_tree.contains(&link.get_target().to_string()) {
+                                results.push(DependentsEntry(package.clone(), link.clone(), None));
+                                continue;
                             }
+                            packages_in_tree.push(link.get_target().to_string());
+                            let dependents = if recurse {
+                                self.get_dependents(
+                                    NeedleInput::Single(link.get_target().to_string()),
+                                    None,
+                                    false,
+                                    true,
+                                    Some(packages_in_tree.clone()),
+                                )?
+                            } else {
+                                vec![]
+                            };
+                            results.push(DependentsEntry(
+                                package.clone(),
+                                link.clone(),
+                                Some(dependents),
+                            ));
+                            needles.push(link.get_target().to_string());
                         }
                     }
                 }
@@ -187,7 +182,7 @@ impl InstalledRepository {
                     if link.get_target() == needle.as_str() {
                         let matches_constraint = constraint
                             .as_ref()
-                            .map_or(true, |c| link.get_constraint().matches(c) == !invert);
+                            .is_none_or(|c| link.get_constraint().matches(c) != invert);
                         if constraint.is_none() || matches_constraint {
                             if packages_in_tree.contains(&link.get_source().to_string()) {
                                 results.push(DependentsEntry(package.clone(), link.clone(), None));
diff --git a/crates/shirabe/src/repository/path_repository.rs b/crates/shirabe/src/repository/path_repository.rs
index cfd42e5..160c917 100644
--- a/crates/shirabe/src/repository/path_repository.rs
+++ b/crates/shirabe/src/repository/path_repository.rs
@@ -209,43 +209,40 @@ impl PathRepository {
                 .get("name")
                 .and_then(|v| v.as_string())
                 .map(|s| s.to_string())
-            {
-                if let Some(version) = self
+                && let Some(version) = self
                     .options
                     .get("versions")
                     .and_then(|v| v.as_array())
                     .and_then(|a| a.get(&name))
                     .and_then(|v| v.as_string())
                     .map(|s| s.to_string())
-                {
-                    package.insert("version".to_string(), PhpMixed::String(version));
-                }
+            {
+                package.insert("version".to_string(), PhpMixed::String(version));
             }
 
             // carry over the root package version if this path repo is in the same git repository as root package
-            if !package.contains_key("version") {
-                if let Some(root_version) = Platform::get_env("COMPOSER_ROOT_VERSION") {
-                    if !root_version.is_empty() {
-                        let mut ref1 = PhpMixed::Null;
-                        let mut ref2 = PhpMixed::Null;
-                        let cmd = PhpMixed::from(vec!["git", "rev-parse", "HEAD"]);
-                        let code1 = self
-                            .process
-                            .borrow_mut()
-                            .execute(cmd.clone(), Some(&mut ref1), Some(path.as_str()))
-                            .unwrap_or(1);
-                        let code2 = self
-                            .process
-                            .borrow_mut()
-                            .execute(cmd, Some(&mut ref2), ())
-                            .unwrap_or(1);
-                        if code1 == 0 && code2 == 0 && ref1.as_string() == ref2.as_string() {
-                            package.insert(
-                                "version".to_string(),
-                                PhpMixed::String(self.version_guesser.get_root_version_from_env()?),
-                            );
-                        }
-                    }
+            if !package.contains_key("version")
+                && let Some(root_version) = Platform::get_env("COMPOSER_ROOT_VERSION")
+                && !root_version.is_empty()
+            {
+                let mut ref1 = PhpMixed::Null;
+                let mut ref2 = PhpMixed::Null;
+                let cmd = PhpMixed::from(vec!["git", "rev-parse", "HEAD"]);
+                let code1 = self
+                    .process
+                    .borrow_mut()
+                    .execute(cmd.clone(), Some(&mut ref1), Some(path.as_str()))
+                    .unwrap_or(1);
+                let code2 = self
+                    .process
+                    .borrow_mut()
+                    .execute(cmd, Some(&mut ref2), ())
+                    .unwrap_or(1);
+                if code1 == 0 && code2 == 0 && ref1.as_string() == ref2.as_string() {
+                    package.insert(
+                        "version".to_string(),
+                        PhpMixed::String(self.version_guesser.get_root_version_from_env()?),
+                    );
                 }
             }
 
diff --git a/crates/shirabe/src/repository/platform_repository.rs b/crates/shirabe/src/repository/platform_repository.rs
index 3136065..f345eaa 100644
--- a/crates/shirabe/src/repository/platform_repository.rs
+++ b/crates/shirabe/src/repository/platform_repository.rs
@@ -70,7 +70,7 @@ impl PlatformRepository {
         runtime: Option<Runtime>,
         hhvm_detector: Option<HhvmDetector>,
     ) -> anyhow::Result<Self> {
-        let runtime = runtime.unwrap_or_else(|| Runtime);
+        let runtime = runtime.unwrap_or(Runtime);
         let hhvm_detector = hhvm_detector.unwrap_or_else(|| HhvmDetector::new(None, None));
         let mut overrides_map: IndexMap<String, PlatformOverride> = IndexMap::new();
         for (name, version) in overrides {
@@ -329,12 +329,10 @@ impl PlatformRepository {
                     .collect(),
             ),
             true,
-        ) {
-            if let Some(xdebug_pretty_version) = XdebugHandler::get_skipped_version() {
-                if !xdebug_pretty_version.is_empty() {
-                    self.add_extension("xdebug", &xdebug_pretty_version)?;
-                }
-            }
+        ) && let Some(xdebug_pretty_version) = XdebugHandler::get_skipped_version()
+            && !xdebug_pretty_version.is_empty()
+        {
+            self.add_extension("xdebug", &xdebug_pretty_version)?;
         }
 
         // Another quick loop, just for possible libraries
@@ -1551,11 +1549,11 @@ impl PlatformRepository {
             } else {
                 format!("actual: {}", package.get_pretty_version())
             };
-            if let Some(overrider) = overrider {
-                if let Some(overrider) = overrider.as_complete() {
-                    let description = overrider.get_description().unwrap_or_default();
-                    overrider.set_description(format!("{}, {}", description, actual_text));
-                }
+            if let Some(overrider) = overrider
+                && let Some(overrider) = overrider.as_complete()
+            {
+                let description = overrider.get_description().unwrap_or_default();
+                overrider.set_description(format!("{}, {}", description, actual_text));
             }
 
             return Ok(());
diff --git a/crates/shirabe/src/repository/repository_factory.rs b/crates/shirabe/src/repository/repository_factory.rs
index 71b1471..d78fc48 100644
--- a/crates/shirabe/src/repository/repository_factory.rs
+++ b/crates/shirabe/src/repository/repository_factory.rs
@@ -48,11 +48,9 @@ impl RepositoryFactory {
                 Some(io.clone()),
             )?;
             let data = json.read()?;
-            let has_packages = data.get("packages").map_or(false, |v| !v.is_null());
-            let has_includes = data.get("includes").map_or(false, |v| !v.is_null());
-            let has_provider_includes = data
-                .get("provider-includes")
-                .map_or(false, |v| !v.is_null());
+            let has_packages = data.get("packages").is_some_and(|v| !v.is_null());
+            let has_includes = data.get("includes").is_some_and(|v| !v.is_null());
+            let has_provider_includes = data.get("provider-includes").is_some_and(|v| !v.is_null());
             if has_packages || has_includes || has_provider_includes {
                 let real_path = std::fs::canonicalize(repository)
                     .ok()
@@ -153,7 +151,7 @@ impl RepositoryFactory {
         };
         if let Some(io) = &io {
             io.borrow_mut()
-                .load_configuration(&mut *config.borrow_mut())?;
+                .load_configuration(&mut config.borrow_mut())?;
         }
 
         let mut owned_rm;
@@ -241,7 +239,7 @@ impl RepositoryFactory {
         )?));
         let mut manager = Self::manager(io.clone(), &config, None, None, None)?;
         io.borrow_mut()
-            .load_configuration(&mut *config.borrow_mut())?;
+            .load_configuration(&mut config.borrow_mut())?;
         Self::default_repos(Some(io), Some(config), Some(&mut manager))
     }
 
diff --git a/crates/shirabe/src/repository/repository_manager.rs b/crates/shirabe/src/repository/repository_manager.rs
index 9027af6..c838657 100644
--- a/crates/shirabe/src/repository/repository_manager.rs
+++ b/crates/shirabe/src/repository/repository_manager.rs
@@ -61,7 +61,7 @@ impl RepositoryManager {
                 name,
                 crate::repository::FindPackageConstraint::Constraint(constraint.clone()),
             )? {
-                return Ok(Some(package.into()));
+                return Ok(Some(package));
             }
         }
         Ok(None)
diff --git a/crates/shirabe/src/repository/repository_set.rs b/crates/shirabe/src/repository/repository_set.rs
index bf7b525..40e7f22 100644
--- a/crates/shirabe/src/repository/repository_set.rs
+++ b/crates/shirabe/src/repository/repository_set.rs
@@ -222,7 +222,7 @@ impl RepositorySet {
         } else {
             'outer: for repository in &self.repositories {
                 let mut name_map: IndexMap<String, Option<AnyConstraint>> = IndexMap::new();
-                name_map.insert(name.to_string(), constraint.as_ref().map(|c| c.clone()));
+                name_map.insert(name.to_string(), constraint.clone());
                 let acceptable = if ignore_stability {
                     // PHP: BasePackage::STABILITIES
                     crate::package::STABILITIES
@@ -314,10 +314,10 @@ impl RepositorySet {
         let mut map: IndexMap<String, AnyConstraint> = IndexMap::new();
         for package in packages {
             // ignore root alias versions as they are not actual package versions and should not matter when it comes to vulnerabilities
-            if let Some(alias) = package.as_alias() {
-                if alias.is_root_package_alias() {
-                    continue;
-                }
+            if let Some(alias) = package.as_alias()
+                && alias.is_root_package_alias()
+            {
+                continue;
             }
             let name = package.get_name().to_string();
             if map.contains_key(&name) {
@@ -452,9 +452,7 @@ impl RepositorySet {
     }
 
     /// Create a pool for dependency resolution from the packages in this repository set.
-    ///
-    /// @param list<string>      $ignoredTypes Packages of those types are ignored
-    /// @param list<string>|null $allowedTypes Only packages of those types are allowed if set to non-null
+    #[allow(clippy::too_many_arguments, reason = "to keep PHP signature")]
     pub fn create_pool(
         &mut self,
         request: &mut Request,
@@ -546,32 +544,32 @@ impl RepositorySet {
                 let version = package.get_version();
                 packages.push(package.clone());
 
-                if let Some(versions) = self.root_aliases.get(&name) {
-                    if let Some(alias) = versions.get(&version) {
-                        while let Some(alias_pkg) = package.as_alias() {
-                            package = alias_pkg.get_alias_of().into();
-                        }
-                        let alias_package: BasePackageHandle =
-                            if let Some(complete) = package.as_complete_package() {
-                                CompleteAliasPackageHandle::new(
-                                    complete,
-                                    alias.alias_normalized.clone(),
-                                    alias.alias.clone(),
-                                )
-                                .into()
-                            } else {
-                                AliasPackageHandle::new(
-                                    package.as_package().unwrap(),
-                                    alias.alias_normalized.clone(),
-                                    alias.alias.clone(),
-                                )
-                                .into()
-                            };
-                        if let Some(alias_handle) = alias_package.as_alias() {
-                            alias_handle.set_root_package_alias(true);
-                        }
-                        packages.push(alias_package);
+                if let Some(versions) = self.root_aliases.get(&name)
+                    && let Some(alias) = versions.get(&version)
+                {
+                    while let Some(alias_pkg) = package.as_alias() {
+                        package = alias_pkg.get_alias_of().into();
                     }
+                    let alias_package: BasePackageHandle =
+                        if let Some(complete) = package.as_complete_package() {
+                            CompleteAliasPackageHandle::new(
+                                complete,
+                                alias.alias_normalized.clone(),
+                                alias.alias.clone(),
+                            )
+                            .into()
+                        } else {
+                            AliasPackageHandle::new(
+                                package.as_package().unwrap(),
+                                alias.alias_normalized.clone(),
+                                alias.alias.clone(),
+                            )
+                            .into()
+                        };
+                    if let Some(alias_handle) = alias_package.as_alias() {
+                        alias_handle.set_root_package_alias(true);
+                    }
+                    packages.push(alias_package);
                 }
             }
         }
@@ -643,16 +641,13 @@ impl RepositorySet {
             IndexMap::new();
 
         for alias in aliases {
-            normalized_aliases
-                .entry(alias.package)
-                .or_insert_with(IndexMap::new)
-                .insert(
-                    alias.version,
-                    RootAliasEntry {
-                        alias: alias.alias,
-                        alias_normalized: alias.alias_normalized,
-                    },
-                );
+            normalized_aliases.entry(alias.package).or_default().insert(
+                alias.version,
+                RootAliasEntry {
+                    alias: alias.alias,
+                    alias_normalized: alias.alias_normalized,
+                },
+            );
         }
 
         normalized_aliases
diff --git a/crates/shirabe/src/repository/vcs/forgejo_driver.rs b/crates/shirabe/src/repository/vcs/forgejo_driver.rs
index df52820..3706e02 100644
--- a/crates/shirabe/src/repository/vcs/forgejo_driver.rs
+++ b/crates/shirabe/src/repository/vcs/forgejo_driver.rs
@@ -76,7 +76,7 @@ impl ForgejoDriver {
             None,
             false,
         ));
-        self.inner.cache.as_mut().map(|c| {
+        if let Some(c) = self.inner.cache.as_mut() {
             c.set_read_only(
                 self.inner
                     .config
@@ -85,7 +85,7 @@ impl ForgejoDriver {
                     .as_bool()
                     .unwrap_or(false),
             )
-        });
+        }
 
         self.fetch_repository_data()?;
 
@@ -114,11 +114,8 @@ impl ForgejoDriver {
         let needs_git_blob = if let PhpMixed::Array(ref arr) = resource {
             let content_empty = arr
                 .get("content")
-                .map_or(true, |v| v.as_string().map_or(true, |s| s.is_empty()));
-            let encoding_none = arr
-                .get("encoding")
-                .and_then(|v| v.as_string())
-                .map_or(false, |s| s == "none");
+                .is_none_or(|v| v.as_string().is_none_or(|s| s.is_empty()));
+            let encoding_none = arr.get("encoding").and_then(|v| v.as_string()) == Some("none");
             let has_git_url = arr.contains_key("git_url");
             content_empty && encoding_none && has_git_url
         } else {
@@ -143,10 +140,7 @@ impl ForgejoDriver {
 
         let content_b64 = if let PhpMixed::Array(ref arr) = resource {
             let has_content = arr.contains_key("content");
-            let encoding_ok = arr
-                .get("encoding")
-                .and_then(|v| v.as_string())
-                .map_or(false, |s| s == "base64");
+            let encoding_ok = arr.get("encoding").and_then(|v| v.as_string()) == Some("base64");
             if has_content && encoding_ok {
                 arr.get("content")
                     .and_then(|v| v.as_string())
@@ -357,25 +351,25 @@ impl ForgejoDriver {
                         file_content,
                         || self.get_change_date(identifier),
                     )?;
-                    if self.inner.should_cache(identifier) {
-                        if let Some(ref composer_map) = c {
-                            let encoded = JsonFile::encode_with_options(
-                                &PhpMixed::Array(
-                                    composer_map
-                                        .iter()
-                                        .map(|(k, v)| (k.clone(), Box::new(v.clone())))
-                                        .collect(),
-                                ),
-                                JsonEncodeOptions {
-                                    pretty_print: false,
-                                    ..Default::default()
-                                },
-                            );
-                            self.inner
-                                .cache
-                                .as_mut()
-                                .map(|c| c.write(identifier, &encoded));
-                        }
+                    if self.inner.should_cache(identifier)
+                        && let Some(ref composer_map) = c
+                    {
+                        let encoded = JsonFile::encode_with_options(
+                            &PhpMixed::Array(
+                                composer_map
+                                    .iter()
+                                    .map(|(k, v)| (k.clone(), Box::new(v.clone())))
+                                    .collect(),
+                            ),
+                            JsonEncodeOptions {
+                                pretty_print: false,
+                                ..Default::default()
+                            },
+                        );
+                        self.inner
+                            .cache
+                            .as_mut()
+                            .map(|c| c.write(identifier, &encoded));
                     }
                     c
                 }
@@ -392,7 +386,7 @@ impl ForgejoDriver {
                 // specials for forgejo
                 let support_not_array = composer_map
                     .get("support")
-                    .map_or(false, |v| v.as_array().is_none());
+                    .is_some_and(|v| v.as_array().is_none());
                 if support_not_array {
                     composer_map.insert("support".to_string(), PhpMixed::Array(IndexMap::new()));
                 }
@@ -400,7 +394,7 @@ impl ForgejoDriver {
                 let has_source = composer_map
                     .get("support")
                     .and_then(|v| v.as_array())
-                    .map_or(false, |arr| arr.contains_key("source"));
+                    .is_some_and(|arr| arr.contains_key("source"));
 
                 if !has_source {
                     let html_url = self
@@ -437,14 +431,9 @@ impl ForgejoDriver {
                 let has_issues = composer_map
                     .get("support")
                     .and_then(|v| v.as_array())
-                    .map_or(false, |arr| arr.contains_key("issues"));
+                    .is_some_and(|arr| arr.contains_key("issues"));
 
-                if !has_issues
-                    && self
-                        .repository_data
-                        .as_ref()
-                        .map_or(false, |r| r.has_issues)
-                {
+                if !has_issues && self.repository_data.as_ref().is_some_and(|r| r.has_issues) {
                     let issues_url = format!(
                         "{}/issues",
                         self.repository_data
@@ -459,10 +448,7 @@ impl ForgejoDriver {
                 }
 
                 if !composer_map.contains_key("abandoned")
-                    && self
-                        .repository_data
-                        .as_ref()
-                        .map_or(false, |r| r.is_archived)
+                    && self.repository_data.as_ref().is_some_and(|r| r.is_archived)
                 {
                     composer_map.insert("abandoned".to_string(), PhpMixed::Bool(true));
                 }
@@ -520,9 +506,8 @@ impl ForgejoDriver {
         let forgejo_domains = config.borrow().get("forgejo-domains");
         let in_domains = if let Some(list) = forgejo_domains.as_list() {
             list.iter().any(|d| {
-                d.as_string().map_or(false, |s| {
-                    s.to_lowercase() == forgejo_url.origin_url.to_lowercase()
-                })
+                d.as_string()
+                    .is_some_and(|s| s.to_lowercase() == forgejo_url.origin_url.to_lowercase())
             })
         } else {
             false
@@ -605,10 +590,10 @@ impl ForgejoDriver {
         let links = explode(",", &header);
         for link in links {
             let mut m: IndexMap<CaptureKey, String> = IndexMap::new();
-            if Preg::match3(r#"{<(.+?)>; *rel="next"}"#, &link, Some(&mut m)) {
-                if let Some(url) = m.get(&CaptureKey::ByIndex(1)) {
-                    return Some(url.clone());
-                }
+            if Preg::match3(r#"{<(.+?)>; *rel="next"}"#, &link, Some(&mut m))
+                && let Some(url) = m.get(&CaptureKey::ByIndex(1))
+            {
+                return Some(url.clone());
             }
         }
 
diff --git a/crates/shirabe/src/repository/vcs/fossil_driver.rs b/crates/shirabe/src/repository/vcs/fossil_driver.rs
index c205379..1da7a2a 100644
--- a/crates/shirabe/src/repository/vcs/fossil_driver.rs
+++ b/crates/shirabe/src/repository/vcs/fossil_driver.rs
@@ -101,7 +101,7 @@ impl FossilDriver {
     pub(crate) fn check_fossil(&self) -> anyhow::Result<()> {
         let mut ignored_output = String::new();
         if self.inner.process.borrow_mut().execute_args(
-            &["fossil", "version"].map(|s| s.to_string()).to_vec(),
+            ["fossil", "version"].map(|s| s.to_string()).as_ref(),
             &mut ignored_output,
             (),
         ) != 0
@@ -141,13 +141,13 @@ impl FossilDriver {
         if is_file(&repo_file)
             && is_dir(&self.checkout_dir)
             && self.inner.process.borrow_mut().execute_args(
-                &["fossil", "info"].map(|s| s.to_string()).to_vec(),
+                ["fossil", "info"].map(|s| s.to_string()).as_ref(),
                 &mut String::new(),
                 Some(self.checkout_dir.clone()),
             ) == 0
         {
             if self.inner.process.borrow_mut().execute_args(
-                &["fossil", "pull"].map(|s| s.to_string()).to_vec(),
+                ["fossil", "pull"].map(|s| s.to_string()).as_ref(),
                 &mut String::new(),
                 Some(self.checkout_dir.clone()),
             ) != 0
@@ -166,9 +166,9 @@ impl FossilDriver {
 
             let mut output = String::new();
             if self.inner.process.borrow_mut().execute_args(
-                &["fossil", "clone", "--", &self.inner.url, &repo_file]
+                ["fossil", "clone", "--", &self.inner.url, &repo_file]
                     .map(|s| s.to_string())
-                    .to_vec(),
+                    .as_ref(),
                 &mut output,
                 (),
             ) != 0
@@ -185,9 +185,9 @@ impl FossilDriver {
             }
 
             if self.inner.process.borrow_mut().execute_args(
-                &["fossil", "open", "--nested", "--", &repo_file]
+                ["fossil", "open", "--nested", "--", &repo_file]
                     .map(|s| s.to_string())
-                    .to_vec(),
+                    .as_ref(),
                 &mut output,
                 Some(self.checkout_dir.clone()),
             ) != 0
@@ -244,9 +244,9 @@ impl FossilDriver {
 
         let mut content = String::new();
         self.inner.process.borrow_mut().execute_args(
-            &["fossil", "cat", "-r", identifier, "--", file]
+            ["fossil", "cat", "-r", identifier, "--", file]
                 .map(|s| s.to_string())
-                .to_vec(),
+                .as_ref(),
             &mut content,
             Some(self.checkout_dir.clone()),
         );
@@ -264,9 +264,9 @@ impl FossilDriver {
     ) -> anyhow::Result<Option<DateTime<FixedOffset>>> {
         let mut output = String::new();
         self.inner.process.borrow_mut().execute_args(
-            &["fossil", "finfo", "-b", "-n", "1", "composer.json"]
+            ["fossil", "finfo", "-b", "-n", "1", "composer.json"]
                 .map(|s| s.to_string())
-                .to_vec(),
+                .as_ref(),
             &mut output,
             Some(self.checkout_dir.clone()),
         );
@@ -282,7 +282,7 @@ impl FossilDriver {
             let mut tags: IndexMap<String, String> = IndexMap::new();
             let mut output = String::new();
             self.inner.process.borrow_mut().execute_args(
-                &["fossil", "tag", "list"].map(|s| s.to_string()).to_vec(),
+                ["fossil", "tag", "list"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(self.checkout_dir.clone()),
             );
@@ -299,12 +299,12 @@ impl FossilDriver {
             let mut branches: IndexMap<String, String> = IndexMap::new();
             let mut output = String::new();
             self.inner.process.borrow_mut().execute_args(
-                &["fossil", "branch", "list"].map(|s| s.to_string()).to_vec(),
+                ["fossil", "branch", "list"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(self.checkout_dir.clone()),
             );
             for branch in self.inner.process.borrow().split_lines(&output) {
-                let branch = Preg::replace(r"/^\*/", "", &branch.trim());
+                let branch = Preg::replace(r"/^\*/", "", branch.trim());
                 let branch = branch.trim().to_string();
                 branches.insert(branch.clone(), branch);
             }
@@ -340,7 +340,7 @@ impl FossilDriver {
             let mut process = ProcessExecutor::new(Some(io));
             let mut output = String::new();
             if process.execute_args(
-                &["fossil", "info"].map(|s| s.to_string()).to_vec(),
+                ["fossil", "info"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(url),
             ) == 0
diff --git a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
index b0985e5..44c0d08 100644
--- a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
+++ b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
@@ -789,16 +789,16 @@ impl GitBitbucketDriver {
             _ => return,
         };
         for clone_link in list {
-            if let PhpMixed::Array(m) = clone_link.as_ref() {
-                if m.get("name").and_then(|v| v.as_string()) == Some("https") {
-                    // Format: https://(user@)bitbucket.org/{user}/{repo}
-                    // Strip username from URL (only present in clone URL's for private repositories)
-                    self.clone_https_url = Preg::replace(
-                        r"/https:\/\/([^@]+@)?/",
-                        "https://",
-                        m.get("href").and_then(|v| v.as_string()).unwrap_or(""),
-                    );
-                }
+            if let PhpMixed::Array(m) = clone_link.as_ref()
+                && m.get("name").and_then(|v| v.as_string()) == Some("https")
+            {
+                // Format: https://(user@)bitbucket.org/{user}/{repo}
+                // Strip username from URL (only present in clone URL's for private repositories)
+                self.clone_https_url = Preg::replace(
+                    r"/https:\/\/([^@]+@)?/",
+                    "https://",
+                    m.get("href").and_then(|v| v.as_string()).unwrap_or(""),
+                );
             }
         }
     }
diff --git a/crates/shirabe/src/repository/vcs/git_driver.rs b/crates/shirabe/src/repository/vcs/git_driver.rs
index 3c950bb..e639649 100644
--- a/crates/shirabe/src/repository/vcs/git_driver.rs
+++ b/crates/shirabe/src/repository/vcs/git_driver.rs
@@ -167,7 +167,7 @@ impl GitDriver {
             None,
             false,
         ));
-        self.inner.cache.as_mut().map(|c| {
+        if let Some(c) = self.inner.cache.as_mut() {
             c.set_read_only(
                 self.inner
                     .config
@@ -176,7 +176,7 @@ impl GitDriver {
                     .as_bool()
                     .unwrap_or(false),
             )
-        });
+        }
 
         Ok(())
     }
@@ -215,11 +215,11 @@ impl GitDriver {
                 for branch in &branches {
                     if !branch.is_empty() {
                         let mut caps: IndexMap<CaptureKey, String> = IndexMap::new();
-                        if Preg::match3(r"{^\* +(\S+)}", branch, Some(&mut caps)) {
-                            if let Some(name) = caps.get(&CaptureKey::ByIndex(1)) {
-                                self.root_identifier = Some(name.clone());
-                                break;
-                            }
+                        if Preg::match3(r"{^\* +(\S+)}", branch, Some(&mut caps))
+                            && let Some(name) = caps.get(&CaptureKey::ByIndex(1))
+                        {
+                            self.root_identifier = Some(name.clone());
+                            break;
                         }
                     }
                 }
@@ -338,16 +338,14 @@ impl GitDriver {
                         r"{^([a-f0-9]{40}) refs/tags/(\S+?)(\^\{\})?$}",
                         &tag,
                         Some(&mut caps),
+                    ) && let (Some(hash), Some(name)) = (
+                        caps.get(&CaptureKey::ByIndex(1)),
+                        caps.get(&CaptureKey::ByIndex(2)),
                     ) {
-                        if let (Some(hash), Some(name)) = (
-                            caps.get(&CaptureKey::ByIndex(1)),
-                            caps.get(&CaptureKey::ByIndex(2)),
-                        ) {
-                            self.tags
-                                .as_mut()
-                                .unwrap()
-                                .insert(name.clone(), hash.clone());
-                        }
+                        self.tags
+                            .as_mut()
+                            .unwrap()
+                            .insert(name.clone(), hash.clone());
                     }
                 }
             }
@@ -379,15 +377,12 @@ impl GitDriver {
                         r"{^(?:\* )? *(\S+) *([a-f0-9]+)(?: .*)?$}",
                         &branch,
                         Some(&mut caps),
-                    ) {
-                        if let (Some(name), Some(hash)) = (
-                            caps.get(&CaptureKey::ByIndex(1)),
-                            caps.get(&CaptureKey::ByIndex(2)),
-                        ) {
-                            if !name.starts_with('-') {
-                                branches.insert(name.clone(), hash.clone());
-                            }
-                        }
+                    ) && let (Some(name), Some(hash)) = (
+                        caps.get(&CaptureKey::ByIndex(1)),
+                        caps.get(&CaptureKey::ByIndex(2)),
+                    ) && !name.starts_with('-')
+                    {
+                        branches.insert(name.clone(), hash.clone());
                     }
                 }
             }
@@ -430,7 +425,7 @@ impl GitDriver {
                 return Ok(true);
             }
             GitUtil::check_for_repo_ownership_error(
-                &process.borrow().get_error_output(),
+                process.borrow().get_error_output(),
                 &url,
                 Some(io.clone()),
             )?;
diff --git a/crates/shirabe/src/repository/vcs/github_driver.rs b/crates/shirabe/src/repository/vcs/github_driver.rs
index 696851e..8c8c81a 100644
--- a/crates/shirabe/src/repository/vcs/github_driver.rs
+++ b/crates/shirabe/src/repository/vcs/github_driver.rs
@@ -130,7 +130,7 @@ impl GitHubDriver {
             None,
             false,
         ));
-        self.inner.cache.as_mut().map(|c| {
+        if let Some(c) = self.inner.cache.as_mut() {
             c.set_read_only(
                 self.inner
                     .config
@@ -139,7 +139,7 @@ impl GitHubDriver {
                     .as_bool()
                     .unwrap_or(false),
             )
-        });
+        }
 
         if self
             .inner
@@ -290,27 +290,27 @@ impl GitHubDriver {
                     || self.get_change_date(identifier),
                 )?;
 
-                if self.inner.should_cache(identifier) {
-                    if let Some(ref composer_map) = composer {
-                        let php_value: PhpMixed = PhpMixed::Array(
-                            composer_map
-                                .iter()
-                                .map(|(k, v)| (k.clone(), Box::new(v.clone())))
-                                .collect(),
-                        );
-                        self.inner.cache.as_mut().map(|c| {
-                            c.write(
-                                identifier,
-                                &JsonFile::encode_with_options(
-                                    &php_value,
-                                    JsonEncodeOptions {
-                                        pretty_print: false,
-                                        ..Default::default()
-                                    },
-                                ),
-                            )
-                        });
-                    }
+                if self.inner.should_cache(identifier)
+                    && let Some(ref composer_map) = composer
+                {
+                    let php_value: PhpMixed = PhpMixed::Array(
+                        composer_map
+                            .iter()
+                            .map(|(k, v)| (k.clone(), Box::new(v.clone())))
+                            .collect(),
+                    );
+                    self.inner.cache.as_mut().map(|c| {
+                        c.write(
+                            identifier,
+                            &JsonFile::encode_with_options(
+                                &php_value,
+                                JsonEncodeOptions {
+                                    pretty_print: false,
+                                    ..Default::default()
+                                },
+                            ),
+                        )
+                    });
                 }
 
                 composer
@@ -379,21 +379,22 @@ impl GitHubDriver {
                     .and_then(|v| v.as_array())
                     .map(|m| m.contains_key("issues"))
                     .unwrap_or(false);
-                if issues_missing && self.has_issues {
-                    if let Some(support) = composer.get_mut("support").and_then(|v| match v {
+                if issues_missing
+                    && self.has_issues
+                    && let Some(support) = composer.get_mut("support").and_then(|v| match v {
                         PhpMixed::Array(m) => Some(m),
                         _ => None,
-                    }) {
-                        support.insert(
-                            "issues".to_string(),
-                            Box::new(PhpMixed::String(format!(
-                                "https://{}/{}/{}/issues",
-                                PhpMixed::String(self.inner.origin_url.clone()),
-                                PhpMixed::String(self.owner.clone()),
-                                PhpMixed::String(self.repository.clone()),
-                            ))),
-                        );
-                    }
+                    })
+                {
+                    support.insert(
+                        "issues".to_string(),
+                        Box::new(PhpMixed::String(format!(
+                            "https://{}/{}/{}/issues",
+                            PhpMixed::String(self.inner.origin_url.clone()),
+                            PhpMixed::String(self.owner.clone()),
+                            PhpMixed::String(self.repository.clone()),
+                        ))),
+                    );
                 }
                 if !composer.contains_key("abandoned") && self.is_archived {
                     composer.insert("abandoned".to_string(), PhpMixed::Bool(true));
@@ -1066,7 +1067,9 @@ impl GitHubDriver {
                         let scopes_failed = array_diff(&scopes_needed, &scopes_issued);
                         // non-authenticated requests get no scopesNeeded, so ask for credentials
                         // authenticated requests which failed some scopes should ask for new credentials too
-                        if headers.is_empty() || scopes_needed.is_empty() || scopes_failed.len() > 0
+                        if headers.is_empty()
+                            || scopes_needed.is_empty()
+                            || !scopes_failed.is_empty()
                         {
                             git_hub_util.authorize_oauth_interactively(
                                 &self.inner.origin_url,
diff --git a/crates/shirabe/src/repository/vcs/gitlab_driver.rs b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
index fc09108..a5e6b73 100644
--- a/crates/shirabe/src/repository/vcs/gitlab_driver.rs
+++ b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
@@ -222,7 +222,7 @@ impl GitLabDriver {
             None,
             false,
         ));
-        self.inner.cache.as_mut().map(|c| {
+        if let Some(c) = self.inner.cache.as_mut() {
             c.set_read_only(
                 self.inner
                     .config
@@ -231,7 +231,7 @@ impl GitLabDriver {
                     .as_bool()
                     .unwrap_or(false),
             )
-        });
+        }
 
         self.fetch_project()?;
 
@@ -283,27 +283,27 @@ impl GitLabDriver {
                     || self.get_change_date(identifier),
                 )?;
 
-                if self.inner.should_cache(identifier) {
-                    if let Some(ref composer_map) = composer {
-                        self.inner.cache.as_mut().map(|c| {
-                            c.write(
-                                identifier,
-                                &JsonFile::encode_with_options(
-                                    &PhpMixed::Array(
-                                        composer_map
-                                            .clone()
-                                            .into_iter()
-                                            .map(|(k, v)| (k, Box::new(v)))
-                                            .collect(),
-                                    ),
-                                    JsonEncodeOptions {
-                                        pretty_print: false,
-                                        ..Default::default()
-                                    },
+                if self.inner.should_cache(identifier)
+                    && let Some(ref composer_map) = composer
+                {
+                    self.inner.cache.as_mut().map(|c| {
+                        c.write(
+                            identifier,
+                            &JsonFile::encode_with_options(
+                                &PhpMixed::Array(
+                                    composer_map
+                                        .clone()
+                                        .into_iter()
+                                        .map(|(k, v)| (k, Box::new(v)))
+                                        .collect(),
                                 ),
-                            )
-                        });
-                    }
+                                JsonEncodeOptions {
+                                    pretty_print: false,
+                                    ..Default::default()
+                                },
+                            ),
+                        )
+                    });
                 }
 
                 composer
@@ -615,7 +615,7 @@ impl GitLabDriver {
                     ]),
                     true,
                 ) {
-                format!("%{}", format!("{:02X}", ord(&character)))
+                format!("%{:02X}", ord(&character))
             } else {
                 character
             };
@@ -828,14 +828,12 @@ impl GitLabDriver {
                             json_map.get("permissions").and_then(|v| v.as_array())
                         {
                             for (_, permission) in permissions {
-                                if let Some(perm_map) = permission.as_array() {
-                                    if let Some(level) =
+                                if let Some(perm_map) = permission.as_array()
+                                    && let Some(level) =
                                         perm_map.get("access_level").and_then(|v| v.as_int())
-                                    {
-                                        if level >= 20 {
-                                            more_than_guest_access = true;
-                                        }
-                                    }
+                                    && level >= 20
+                                {
+                                    more_than_guest_access = true;
                                 }
                             }
                         }
@@ -874,7 +872,7 @@ impl GitLabDriver {
                         }
 
                         if !empty(
-                            &*json_map
+                            &json_map
                                 .get("id")
                                 .cloned()
                                 .unwrap_or(Box::new(PhpMixed::Null)),
diff --git a/crates/shirabe/src/repository/vcs/hg_driver.rs b/crates/shirabe/src/repository/vcs/hg_driver.rs
index 63a400c..4a6188e 100644
--- a/crates/shirabe/src/repository/vcs/hg_driver.rs
+++ b/crates/shirabe/src/repository/vcs/hg_driver.rs
@@ -85,19 +85,19 @@ impl HgDriver {
 
             let hg_utils = HgUtils::new(
                 self.inner.io.clone(),
-                &*self.inner.config.borrow(),
+                &self.inner.config.borrow(),
                 &self.inner.process,
             );
 
             if is_dir(&self.repo_dir)
                 && self.inner.process.borrow_mut().execute_args(
-                    &["hg", "summary"].map(|s| s.to_string()).to_vec(),
+                    ["hg", "summary"].map(|s| s.to_string()).as_ref(),
                     &mut String::new(),
                     Some(self.repo_dir.clone()),
                 ) == 0
             {
                 if self.inner.process.borrow_mut().execute_args(
-                    &["hg", "pull"].map(|s| s.to_string()).to_vec(),
+                    ["hg", "pull"].map(|s| s.to_string()).as_ref(),
                     &mut String::new(),
                     Some(self.repo_dir.clone()),
                 ) != 0
@@ -134,9 +134,9 @@ impl HgDriver {
         if self.root_identifier.is_none() {
             let mut output = String::new();
             self.inner.process.borrow_mut().execute_args(
-                &["hg", "tip", "--template", "{node}"]
+                ["hg", "tip", "--template", "{node}"]
                     .map(|s| s.to_string())
-                    .to_vec(),
+                    .as_ref(),
                 &mut output,
                 Some(self.repo_dir.clone()),
             );
@@ -214,7 +214,7 @@ impl HgDriver {
 
         let mut output = String::new();
         self.inner.process.borrow_mut().execute_args(
-            &[
+            [
                 "hg",
                 "log",
                 "--template",
@@ -223,7 +223,7 @@ impl HgDriver {
                 identifier,
             ]
             .map(|s| s.to_string())
-            .to_vec(),
+            .as_ref(),
             &mut output,
             Some(self.repo_dir.clone()),
         );
@@ -237,7 +237,7 @@ impl HgDriver {
             let mut tags: IndexMap<String, String> = IndexMap::new();
             let mut output = String::new();
             self.inner.process.borrow_mut().execute_args(
-                &["hg", "tags"].map(|s| s.to_string()).to_vec(),
+                ["hg", "tags"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(self.repo_dir.clone()),
             );
@@ -267,7 +267,7 @@ impl HgDriver {
 
             let mut output = String::new();
             self.inner.process.borrow_mut().execute_args(
-                &["hg", "branches"].map(|s| s.to_string()).to_vec(),
+                ["hg", "branches"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(self.repo_dir.clone()),
             );
@@ -288,7 +288,7 @@ impl HgDriver {
 
             output.clear();
             self.inner.process.borrow_mut().execute_args(
-                &["hg", "bookmarks"].map(|s| s.to_string()).to_vec(),
+                ["hg", "bookmarks"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(self.repo_dir.clone()),
             );
@@ -337,7 +337,7 @@ impl HgDriver {
             let mut process = crate::util::ProcessExecutor::new(Some(io.clone()));
             let mut output = String::new();
             if process.execute_args(
-                &["hg", "summary"].map(|s| s.to_string()).to_vec(),
+                ["hg", "summary"].map(|s| s.to_string()).as_ref(),
                 &mut output,
                 Some(url),
             ) == 0
@@ -353,9 +353,9 @@ impl HgDriver {
         let mut process = crate::util::ProcessExecutor::new(Some(io));
         let mut ignored = String::new();
         let exit = process.execute_args(
-            &["hg", "identify", "--", url]
+            ["hg", "identify", "--", url]
                 .map(|s| s.to_string())
-                .to_vec(),
+                .as_ref(),
             &mut ignored,
             (),
         );
diff --git a/crates/shirabe/src/repository/vcs/perforce_driver.rs b/crates/shirabe/src/repository/vcs/perforce_driver.rs
index 10cf913..3077cff 100644
--- a/crates/shirabe/src/repository/vcs/perforce_driver.rs
+++ b/crates/shirabe/src/repository/vcs/perforce_driver.rs
@@ -50,10 +50,9 @@ impl PerforceDriver {
             .repo_config
             .get("branch")
             .and_then(|v| v.as_string())
+            && !branch.is_empty()
         {
-            if !branch.is_empty() {
-                self.branch = branch.to_string();
-            }
+            self.branch = branch.to_string();
         }
 
         let repo_config = self.inner.repo_config.clone();
@@ -171,7 +170,7 @@ impl PerforceDriver {
             .as_mut()
             .unwrap()
             .get_composer_information(&path)
-            .map_or(false, |info| info.map_or(false, |i| !i.is_empty()))
+            .is_ok_and(|info| info.is_some_and(|i| !i.is_empty()))
     }
 
     pub fn get_contents(&self, _url: &str) -> anyhow::Result<Response> {
diff --git a/crates/shirabe/src/repository/vcs/svn_driver.rs b/crates/shirabe/src/repository/vcs/svn_driver.rs
index b48ce99..6346a84 100644
--- a/crates/shirabe/src/repository/vcs/svn_driver.rs
+++ b/crates/shirabe/src/repository/vcs/svn_driver.rs
@@ -168,33 +168,32 @@ impl SvnDriver {
         identifier: &str,
     ) -> Result<Option<IndexMap<String, PhpMixed>>> {
         if !self.inner.info_cache.contains_key(identifier) {
-            if self.should_cache(identifier) {
-                if let Some(mut res) = self
+            if self.should_cache(identifier)
+                && let Some(mut res) = self
                     .inner
                     .cache
                     .as_mut()
                     .and_then(|c| c.read(&format!("{}.json", identifier)))
-                {
-                    // old cache files had '' stored instead of null due to af3783b5f40bae32a23e353eaf0a00c9b8ce82e2, so we make sure here that we always return null or array
-                    // and fix outdated invalid cache files
-                    if res == "\"\"" {
-                        res = "null".to_string();
-                        self.inner
-                            .cache
-                            .as_mut()
-                            .unwrap()
-                            .write(&format!("{}.json", identifier), &res)?;
-                    }
-
-                    let parsed = JsonFile::parse_json(Some(res.as_str()), None)?;
-                    let composer: Option<IndexMap<String, PhpMixed>> = parsed
-                        .as_array()
-                        .map(|m| m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect());
+            {
+                // old cache files had '' stored instead of null due to af3783b5f40bae32a23e353eaf0a00c9b8ce82e2, so we make sure here that we always return null or array
+                // and fix outdated invalid cache files
+                if res == "\"\"" {
+                    res = "null".to_string();
                     self.inner
-                        .info_cache
-                        .insert(identifier.to_string(), composer.clone());
-                    return Ok(composer);
+                        .cache
+                        .as_mut()
+                        .unwrap()
+                        .write(&format!("{}.json", identifier), &res)?;
                 }
+
+                let parsed = JsonFile::parse_json(Some(res.as_str()), None)?;
+                let composer: Option<IndexMap<String, PhpMixed>> = parsed
+                    .as_array()
+                    .map(|m| m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect());
+                self.inner
+                    .info_cache
+                    .insert(identifier.to_string(), composer.clone());
+                return Ok(composer);
             }
 
             let base_result =
@@ -290,7 +289,7 @@ impl SvnDriver {
                 return Err(e);
             }
         };
-        if trim(&output, None) == "" {
+        if trim(&output, None).is_empty() {
             return Ok(None);
         }
 
@@ -506,14 +505,14 @@ impl SvnDriver {
         }
 
         // Subversion client 1.7 and older
-        if stripos(&process.get_error_output(), "authorization failed:").is_some() {
+        if stripos(process.get_error_output(), "authorization failed:").is_some() {
             // This is likely a remote Subversion repository that requires
             // authentication. We will handle actual authentication later.
             return Ok(true);
         }
 
         // Subversion client 1.8 and newer
-        if stripos(&process.get_error_output(), "Authentication failed").is_some() {
+        if stripos(process.get_error_output(), "Authentication failed").is_some() {
             // This is likely a remote Subversion or newer repository that requires
             // authentication. We will handle actual authentication later.
             return Ok(true);
diff --git a/crates/shirabe/src/repository/vcs/vcs_driver.rs b/crates/shirabe/src/repository/vcs/vcs_driver.rs
index d1bb3cc..ac7496d 100644
--- a/crates/shirabe/src/repository/vcs/vcs_driver.rs
+++ b/crates/shirabe/src/repository/vcs/vcs_driver.rs
@@ -119,17 +119,16 @@ impl VcsDriverBase {
         let mut composer: IndexMap<String, PhpMixed> =
             array.into_iter().map(|(k, v)| (k, *v)).collect();
 
-        if !composer.contains_key("time")
+        if (!composer.contains_key("time")
             || composer
                 .get("time")
-                .map_or(true, |v| v.as_string().map_or(true, |s| s.is_empty()))
+                .is_none_or(|v| v.as_string().is_none_or(|s| s.is_empty())))
+            && let Some(d) = change_date()?
         {
-            if let Some(d) = change_date()? {
-                composer.insert(
-                    "time".to_string(),
-                    PhpMixed::String(d.format(DATE_RFC3339).to_string()),
-                );
-            }
+            composer.insert(
+                "time".to_string(),
+                PhpMixed::String(d.format(DATE_RFC3339).to_string()),
+            );
         }
 
         Ok(Some(composer))
@@ -150,16 +149,16 @@ impl VcsDriverBase {
                 self.info_cache.get(identifier).and_then(|v| v.clone()),
             ));
         }
-        if self.should_cache(identifier) {
-            if let Some(res) = self.cache.as_mut().and_then(|c| c.read(identifier)) {
-                let parsed = JsonFile::parse_json(Some(&res), None)?;
-                let composer: Option<IndexMap<String, PhpMixed>> = parsed
-                    .as_array()
-                    .map(|m| m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect());
-                self.info_cache
-                    .insert(identifier.to_string(), composer.clone());
-                return Ok(Some(composer));
-            }
+        if self.should_cache(identifier)
+            && let Some(res) = self.cache.as_mut().and_then(|c| c.read(identifier))
+        {
+            let parsed = JsonFile::parse_json(Some(&res), None)?;
+            let composer: Option<IndexMap<String, PhpMixed>> = parsed
+                .as_array()
+                .map(|m| m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect());
+            self.info_cache
+                .insert(identifier.to_string(), composer.clone());
+            return Ok(Some(composer));
         }
         Ok(None)
     }
@@ -215,38 +214,38 @@ pub trait VcsDriver: VcsDriverInterface {
         identifier: &str,
     ) -> anyhow::Result<Option<IndexMap<String, PhpMixed>>> {
         if !self.info_cache().contains_key(identifier) {
-            if self.should_cache(identifier) {
-                if let Some(res) = self.cache_mut().and_then(|c| c.read(identifier)) {
-                    let parsed = JsonFile::parse_json(Some(&res), None)?;
-                    let parsed_map: Option<IndexMap<String, PhpMixed>> = match parsed {
-                        PhpMixed::Array(a) => Some(a.into_iter().map(|(k, v)| (k, *v)).collect()),
-                        _ => None,
-                    };
-                    self.info_cache_mut()
-                        .insert(identifier.to_string(), parsed_map);
-                    return Ok(self.info_cache().get(identifier).and_then(|v| v.clone()));
-                }
+            if self.should_cache(identifier)
+                && let Some(res) = self.cache_mut().and_then(|c| c.read(identifier))
+            {
+                let parsed = JsonFile::parse_json(Some(&res), None)?;
+                let parsed_map: Option<IndexMap<String, PhpMixed>> = match parsed {
+                    PhpMixed::Array(a) => Some(a.into_iter().map(|(k, v)| (k, *v)).collect()),
+                    _ => None,
+                };
+                self.info_cache_mut()
+                    .insert(identifier.to_string(), parsed_map);
+                return Ok(self.info_cache().get(identifier).and_then(|v| v.clone()));
             }
 
             let composer = self.get_base_composer_information(identifier)?;
 
-            if self.should_cache(identifier) {
-                if let Some(ref composer_map) = composer {
-                    let composer_mixed = PhpMixed::Array(
-                        composer_map
-                            .iter()
-                            .map(|(k, v)| (k.clone(), Box::new(v.clone())))
-                            .collect(),
-                    );
-                    let encoded = JsonFile::encode_with_options(
-                        &composer_mixed,
-                        JsonEncodeOptions {
-                            pretty_print: false,
-                            ..Default::default()
-                        },
-                    );
-                    self.cache_mut().map(|c| c.write(identifier, &encoded));
-                }
+            if self.should_cache(identifier)
+                && let Some(ref composer_map) = composer
+            {
+                let composer_mixed = PhpMixed::Array(
+                    composer_map
+                        .iter()
+                        .map(|(k, v)| (k.clone(), Box::new(v.clone())))
+                        .collect(),
+                );
+                let encoded = JsonFile::encode_with_options(
+                    &composer_mixed,
+                    JsonEncodeOptions {
+                        pretty_print: false,
+                        ..Default::default()
+                    },
+                );
+                self.cache_mut().map(|c| c.write(identifier, &encoded));
             }
 
             self.info_cache_mut()
@@ -278,27 +277,26 @@ pub trait VcsDriver: VcsDriverInterface {
             _ => return Ok(None),
         };
 
-        if !composer.contains_key("time")
+        if (!composer.contains_key("time")
             || composer
                 .get("time")
-                .map_or(true, |v| v.as_string().map_or(true, |s| s.is_empty()))
+                .is_none_or(|v| v.as_string().is_none_or(|s| s.is_empty())))
+            && let Some(change_date) = self.get_change_date(identifier)?
         {
-            if let Some(change_date) = self.get_change_date(identifier)? {
-                composer.insert(
-                    "time".to_string(),
-                    PhpMixed::String(change_date.format(DATE_RFC3339).to_string()),
-                );
-            }
+            composer.insert(
+                "time".to_string(),
+                PhpMixed::String(change_date.format(DATE_RFC3339).to_string()),
+            );
         }
 
         Ok(Some(composer))
     }
 
     fn has_composer_file(&mut self, identifier: &str) -> bool {
-        match VcsDriver::get_composer_information(self, identifier) {
-            Ok(Some(_)) => true,
-            _ => false,
-        }
+        matches!(
+            VcsDriver::get_composer_information(self, identifier),
+            Ok(Some(_))
+        )
     }
 
     fn get_scheme(&self) -> &str {
diff --git a/crates/shirabe/src/repository/vcs_repository.rs b/crates/shirabe/src/repository/vcs_repository.rs
index ebab76f..de51a34 100644
--- a/crates/shirabe/src/repository/vcs_repository.rs
+++ b/crates/shirabe/src/repository/vcs_repository.rs
@@ -84,8 +84,7 @@ impl ConfigurableRepositoryInterface for VcsRepository {
 }
 
 impl VcsRepository {
-    /// @param array{url: string, type?: string}&array<string, mixed> $repoConfig
-    /// @param array<string, class-string<VcsDriverInterface>>|null $drivers
+    #[allow(clippy::too_many_arguments, reason = "to keep PHP signature")]
     pub fn new(
         mut repo_config: IndexMap<String, PhpMixed>,
         io: std::rc::Rc<std::cell::RefCell<dyn IOInterface>>,
@@ -315,10 +314,10 @@ impl VcsRepository {
                             }
                             Ok(None) => {}
                             Err(e) => {
-                                if let Some(te) = e.downcast_ref::<TransportException>() {
-                                    if self.should_rethrow_transport_exception(te) {
-                                        return Err(e);
-                                    }
+                                if let Some(te) = e.downcast_ref::<TransportException>()
+                                    && self.should_rethrow_transport_exception(te)
+                                {
+                                    return Err(e);
                                 }
                                 if is_very_verbose {
                                     self.io.write_error(&format!(
@@ -331,10 +330,10 @@ impl VcsRepository {
                     }
                 }
                 Err(e) => {
-                    if let Some(te) = e.downcast_ref::<TransportException>() {
-                        if self.should_rethrow_transport_exception(te) {
-                            return Err(e);
-                        }
+                    if let Some(te) = e.downcast_ref::<TransportException>()
+                        && self.should_rethrow_transport_exception(te)
+                    {
+                        return Err(e);
                     }
                     if is_very_verbose {
                         self.io.write_error(&format!(
@@ -528,7 +527,7 @@ impl VcsRepository {
                 if let Some(te) = e.downcast_ref::<TransportException>() {
                     self.version_transport_exceptions
                         .entry("tags".to_string())
-                        .or_insert_with(IndexMap::new)
+                        .or_default()
                         .insert(tag.clone(), te.clone());
                     if te.get_code() == 404 {
                         self.empty_references.push(identifier.clone());
@@ -701,15 +700,15 @@ impl VcsRepository {
                     .loader
                     .as_ref()
                     .and_then(|l| l.as_any().downcast_ref::<ValidatingArrayLoader>());
-                if let Some(validating) = loader_as_validating {
-                    if !validating.get_warnings().is_empty() {
-                        return Err(InvalidPackageException::new(
-                            validating.get_errors().to_vec(),
-                            validating.get_warnings().to_vec(),
-                            package_data,
-                        )
-                        .into());
-                    }
+                if let Some(validating) = loader_as_validating
+                    && !validating.get_warnings().is_empty()
+                {
+                    return Err(InvalidPackageException::new(
+                        validating.get_errors().to_vec(),
+                        validating.get_warnings().to_vec(),
+                        package_data,
+                    )
+                    .into());
                 }
                 self.inner.add_package(package)?;
                 Ok(())
@@ -718,7 +717,7 @@ impl VcsRepository {
                 if let Some(te) = e.downcast_ref::<TransportException>() {
                     self.version_transport_exceptions
                         .entry("branches".to_string())
-                        .or_insert_with(IndexMap::new)
+                        .or_default()
                         .insert(branch.clone(), te.clone());
                     if te.get_code() == 404 {
                         self.empty_references.push(identifier.clone());
@@ -830,10 +829,12 @@ impl VcsRepository {
             PhpMixed::Array(m) => m.get("reference").cloned(),
             _ => None,
         });
-        if dist_is_array && dist_lacks_reference && source_reference.is_some() {
-            if let Some(PhpMixed::Array(dist_map)) = data.get_mut("dist") {
-                dist_map.insert("reference".to_string(), source_reference.unwrap());
-            }
+        if dist_is_array
+            && dist_lacks_reference
+            && source_reference.is_some()
+            && let Some(PhpMixed::Array(dist_map)) = data.get_mut("dist")
+        {
+            dist_map.insert("reference".to_string(), source_reference.unwrap());
         }
 
         Ok(data)