refactor: auto-fix clippy warnings

3 files changed, 525 insertions, 555 deletions

diff --git a/crates/shirabe/src/package/loader/array_loader.rs b/crates/shirabe/src/package/loader/array_loader.rs
index 222b5df..889624d 100644
--- a/crates/shirabe/src/package/loader/array_loader.rs
+++ b/crates/shirabe/src/package/loader/array_loader.rs
@@ -35,10 +35,7 @@ pub struct ArrayLoader {
 
 impl ArrayLoader {
     pub fn new(parser: Option<VersionParser>, load_options: bool) -> Self {
-        let parser = match parser {
-            Some(p) => p,
-            None => VersionParser::new(),
-        };
+        let parser = parser.unwrap_or_default();
         Self {
             version_parser: parser,
             load_options,
@@ -340,11 +337,11 @@ impl ArrayLoader {
                 .set_target_dir(target_dir.as_string().map(|s| s.to_string()));
         }
 
-        if let Some(extra) = config.get("extra") {
-            if matches!(extra, PhpMixed::Array(_)) {
-                let extra_map = php_to_map(extra);
-                package.package_mut().set_extra(extra_map);
-            }
+        if let Some(extra) = config.get("extra")
+            && matches!(extra, PhpMixed::Array(_))
+        {
+            let extra_map = php_to_map(extra);
+            package.package_mut().set_extra(extra_map);
         }
 
         if let Some(bin) = config.get("bin").cloned() {
@@ -355,13 +352,13 @@ impl ArrayLoader {
             if let PhpMixed::List(ref mut list) = bin_list {
                 for item in list.iter_mut() {
                     if let Some(s) = item.as_string() {
-                        *item = Box::new(PhpMixed::String(ltrim(s, Some("/"))));
+                        **item = PhpMixed::String(ltrim(s, Some("/")));
                     }
                 }
             } else if let PhpMixed::Array(ref mut map) = bin_list {
                 for (_k, v) in map.iter_mut() {
                     if let Some(s) = v.as_string() {
-                        *v = Box::new(PhpMixed::String(ltrim(s, Some("/"))));
+                        **v = PhpMixed::String(ltrim(s, Some("/")));
                     }
                 }
             }
@@ -376,10 +373,10 @@ impl ArrayLoader {
                 .set_installation_source(installation_source.as_string().map(|s| s.to_string()));
         }
 
-        if let Some(default_branch) = config.get("default-branch") {
-            if default_branch.as_bool() == Some(true) {
-                package.package_mut().set_is_default_branch(true);
-            }
+        if let Some(default_branch) = config.get("default-branch")
+            && default_branch.as_bool() == Some(true)
+        {
+            package.package_mut().set_is_default_branch(true);
         }
 
         if let Some(source) = config.get("source").cloned() {
@@ -473,25 +470,23 @@ impl ArrayLoader {
             }
         }
 
-        if let Some(suggest) = config.get("suggest").cloned() {
-            if let PhpMixed::Array(mut suggest_map) = suggest {
-                for (target, reason) in suggest_map.iter_mut() {
-                    if let Some(r) = reason.as_string() {
-                        if trim(r, None) == "self.version" {
-                            *reason = Box::new(PhpMixed::String(
-                                package.get_pretty_version().to_string(),
-                            ));
-                            let _ = target;
-                        }
-                    }
+        if let Some(suggest) = config.get("suggest").cloned()
+            && let PhpMixed::Array(mut suggest_map) = suggest
+        {
+            for (target, reason) in suggest_map.iter_mut() {
+                if let Some(r) = reason.as_string()
+                    && trim(r, None) == "self.version"
+                {
+                    **reason = PhpMixed::String(package.get_pretty_version().to_string());
+                    let _ = target;
                 }
-                let suggests: IndexMap<String, String> = suggest_map
-                    .iter()
-                    .map(|(k, v)| (k.clone(), strval(v)))
-                    .collect();
-                config.insert("suggest".to_string(), PhpMixed::Array(suggest_map));
-                package.package_mut().set_suggests(suggests);
             }
+            let suggests: IndexMap<String, String> = suggest_map
+                .iter()
+                .map(|(k, v)| (k.clone(), strval(v)))
+                .collect();
+            config.insert("suggest".to_string(), PhpMixed::Array(suggest_map));
+            package.package_mut().set_suggests(suggests);
         }
 
         if let Some(autoload) = config.get("autoload") {
@@ -514,201 +509,198 @@ impl ArrayLoader {
             package.package_mut().set_php_ext(Some(php_ext_map));
         }
 
-        if let Some(time_value) = config.get("time") {
-            if !shirabe_php_shim::empty(time_value) {
-                let time_str = time_value.as_string().unwrap_or("");
-                let time = if Preg::is_match(r"/^\d++$/D", time_str) {
-                    format!("@{}", time_str)
-                } else {
-                    time_str.to_string()
-                };
+        if let Some(time_value) = config.get("time")
+            && !shirabe_php_shim::empty(time_value)
+        {
+            let time_str = time_value.as_string().unwrap_or("");
+            let time = if Preg::is_match(r"/^\d++$/D", time_str) {
+                format!("@{}", time_str)
+            } else {
+                time_str.to_string()
+            };
 
-                if let Ok(date) = shirabe_php_shim::date_create::<Utc>(&time) {
-                    package.package_mut().set_release_date(Some(date));
-                }
+            if let Ok(date) = shirabe_php_shim::date_create::<Utc>(&time) {
+                package.package_mut().set_release_date(Some(date));
             }
         }
 
-        if let Some(notification_url) = config.get("notification-url") {
-            if !shirabe_php_shim::empty(notification_url) {
-                package
-                    .package_mut()
-                    .set_notification_url(strval(notification_url));
-            }
+        if let Some(notification_url) = config.get("notification-url")
+            && !shirabe_php_shim::empty(notification_url)
+        {
+            package
+                .package_mut()
+                .set_notification_url(strval(notification_url));
         }
 
-        if let Some(archive) = config.get("archive").cloned() {
-            if let PhpMixed::Array(archive_map) = archive {
-                if let Some(name) = archive_map.get("name") {
-                    if !shirabe_php_shim::empty(name) {
-                        package.complete_mut().set_archive_name(strval(name));
-                    }
-                }
-                if let Some(exclude) = archive_map.get("exclude") {
-                    if !shirabe_php_shim::empty(exclude) {
-                        package
-                            .complete_mut()
-                            .set_archive_excludes(php_to_string_vec(exclude));
-                    }
-                }
+        if let Some(archive) = config.get("archive").cloned()
+            && let PhpMixed::Array(archive_map) = archive
+        {
+            if let Some(name) = archive_map.get("name")
+                && !shirabe_php_shim::empty(name)
+            {
+                package.complete_mut().set_archive_name(strval(name));
+            }
+            if let Some(exclude) = archive_map.get("exclude")
+                && !shirabe_php_shim::empty(exclude)
+            {
+                package
+                    .complete_mut()
+                    .set_archive_excludes(php_to_string_vec(exclude));
             }
         }
 
-        if let Some(scripts) = config.get("scripts").cloned() {
-            if let PhpMixed::Array(mut scripts_map) = scripts {
-                for (event, listeners) in scripts_map.iter_mut() {
-                    let listeners_array = match listeners.as_ref() {
-                        PhpMixed::Array(_) | PhpMixed::List(_) => listeners.clone(),
-                        other => Box::new(PhpMixed::List(vec![Box::new(other.clone())])),
-                    };
-                    *listeners = listeners_array;
-                    let _ = event;
-                }
-                for reserved in ["composer", "php", "putenv"].iter() {
-                    if scripts_map.contains_key(*reserved) {
-                        trigger_error(
-                            &format!(
-                                "The `{}` script name is reserved for internal use, please avoid defining it",
-                                reserved
-                            ),
-                            E_USER_DEPRECATED,
-                        );
-                    }
+        if let Some(scripts) = config.get("scripts").cloned()
+            && let PhpMixed::Array(mut scripts_map) = scripts
+        {
+            for (event, listeners) in scripts_map.iter_mut() {
+                let listeners_array = match listeners.as_ref() {
+                    PhpMixed::Array(_) | PhpMixed::List(_) => listeners.clone(),
+                    other => Box::new(PhpMixed::List(vec![Box::new(other.clone())])),
+                };
+                *listeners = listeners_array;
+                let _ = event;
+            }
+            for reserved in ["composer", "php", "putenv"].iter() {
+                if scripts_map.contains_key(*reserved) {
+                    trigger_error(
+                        &format!(
+                            "The `{}` script name is reserved for internal use, please avoid defining it",
+                            reserved
+                        ),
+                        E_USER_DEPRECATED,
+                    );
                 }
-                let scripts: IndexMap<String, Vec<String>> = scripts_map
-                    .iter()
-                    .map(|(k, v)| (k.clone(), php_to_string_vec(v)))
-                    .collect();
-                config.insert("scripts".to_string(), PhpMixed::Array(scripts_map));
-                package.complete_mut().set_scripts(scripts);
             }
+            let scripts: IndexMap<String, Vec<String>> = scripts_map
+                .iter()
+                .map(|(k, v)| (k.clone(), php_to_string_vec(v)))
+                .collect();
+            config.insert("scripts".to_string(), PhpMixed::Array(scripts_map));
+            package.complete_mut().set_scripts(scripts);
         }
 
-        if let Some(description) = config.get("description") {
-            if !shirabe_php_shim::empty(description) && is_string(description) {
-                package
-                    .complete_mut()
-                    .set_description(description.as_string().unwrap_or("").to_string());
-            }
+        if let Some(description) = config.get("description")
+            && !shirabe_php_shim::empty(description)
+            && is_string(description)
+        {
+            package
+                .complete_mut()
+                .set_description(description.as_string().unwrap_or("").to_string());
         }
 
-        if let Some(homepage) = config.get("homepage") {
-            if !shirabe_php_shim::empty(homepage) && is_string(homepage) {
-                package
-                    .complete_mut()
-                    .set_homepage(homepage.as_string().unwrap_or("").to_string());
-            }
+        if let Some(homepage) = config.get("homepage")
+            && !shirabe_php_shim::empty(homepage)
+            && is_string(homepage)
+        {
+            package
+                .complete_mut()
+                .set_homepage(homepage.as_string().unwrap_or("").to_string());
         }
 
-        if let Some(keywords) = config.get("keywords") {
-            if !shirabe_php_shim::empty(keywords) {
-                if matches!(keywords, PhpMixed::Array(_) | PhpMixed::List(_)) {
-                    let keywords_vec: Vec<String> = match keywords {
-                        PhpMixed::List(list) => list.iter().map(|v| strval(v)).collect(),
-                        PhpMixed::Array(map) => map.values().map(|v| strval(v)).collect(),
-                        _ => vec![],
-                    };
-                    package.complete_mut().set_keywords(keywords_vec);
-                }
-            }
+        if let Some(keywords) = config.get("keywords")
+            && !shirabe_php_shim::empty(keywords)
+            && matches!(keywords, PhpMixed::Array(_) | PhpMixed::List(_))
+        {
+            let keywords_vec: Vec<String> = match keywords {
+                PhpMixed::List(list) => list.iter().map(|v| strval(v)).collect(),
+                PhpMixed::Array(map) => map.values().map(|v| strval(v)).collect(),
+                _ => vec![],
+            };
+            package.complete_mut().set_keywords(keywords_vec);
         }
 
-        if let Some(license) = config.get("license") {
-            if !shirabe_php_shim::empty(license) {
-                let license_vec: Vec<String> = match license {
-                    PhpMixed::Array(map) => map
-                        .values()
-                        .map(|v| v.as_string().unwrap_or("").to_string())
-                        .collect(),
-                    PhpMixed::List(list) => list
-                        .iter()
-                        .map(|v| v.as_string().unwrap_or("").to_string())
-                        .collect(),
-                    other => vec![other.as_string().unwrap_or("").to_string()],
-                };
-                package.complete_mut().set_license(license_vec);
-            }
+        if let Some(license) = config.get("license")
+            && !shirabe_php_shim::empty(license)
+        {
+            let license_vec: Vec<String> = match license {
+                PhpMixed::Array(map) => map
+                    .values()
+                    .map(|v| v.as_string().unwrap_or("").to_string())
+                    .collect(),
+                PhpMixed::List(list) => list
+                    .iter()
+                    .map(|v| v.as_string().unwrap_or("").to_string())
+                    .collect(),
+                other => vec![other.as_string().unwrap_or("").to_string()],
+            };
+            package.complete_mut().set_license(license_vec);
         }
 
-        if let Some(authors) = config.get("authors") {
-            if !shirabe_php_shim::empty(authors) {
-                if let PhpMixed::List(list) = authors {
-                    let authors_vec: Vec<IndexMap<String, String>> = list
-                        .iter()
-                        .filter_map(|v| match v.as_ref() {
-                            PhpMixed::Array(m) => Some(
-                                m.iter()
-                                    .map(|(k, v)| {
-                                        (k.clone(), v.as_string().unwrap_or("").to_string())
-                                    })
-                                    .collect(),
-                            ),
-                            _ => None,
-                        })
-                        .collect();
-                    package.complete_mut().set_authors(authors_vec);
-                }
-            }
+        if let Some(authors) = config.get("authors")
+            && !shirabe_php_shim::empty(authors)
+            && let PhpMixed::List(list) = authors
+        {
+            let authors_vec: Vec<IndexMap<String, String>> = list
+                .iter()
+                .filter_map(|v| match v.as_ref() {
+                    PhpMixed::Array(m) => Some(
+                        m.iter()
+                            .map(|(k, v)| (k.clone(), v.as_string().unwrap_or("").to_string()))
+                            .collect(),
+                    ),
+                    _ => None,
+                })
+                .collect();
+            package.complete_mut().set_authors(authors_vec);
         }
 
-        if let Some(support) = config.get("support") {
-            if let PhpMixed::Array(map) = support {
-                let support_map: IndexMap<String, String> = map
-                    .iter()
-                    .map(|(k, v)| (k.clone(), v.as_string().unwrap_or("").to_string()))
-                    .collect();
-                package.complete_mut().set_support(support_map);
-            }
+        if let Some(support) = config.get("support")
+            && let PhpMixed::Array(map) = support
+        {
+            let support_map: IndexMap<String, String> = map
+                .iter()
+                .map(|(k, v)| (k.clone(), v.as_string().unwrap_or("").to_string()))
+                .collect();
+            package.complete_mut().set_support(support_map);
         }
 
-        if let Some(funding) = config.get("funding") {
-            if !shirabe_php_shim::empty(funding) {
-                if let PhpMixed::List(list) = funding {
-                    let funding_vec: Vec<IndexMap<String, PhpMixed>> = list
-                        .iter()
-                        .filter_map(|v| match v.as_ref() {
-                            PhpMixed::Array(m) => {
-                                Some(m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect())
-                            }
-                            _ => None,
-                        })
-                        .collect();
-                    package.complete_mut().set_funding(funding_vec);
-                }
-            }
+        if let Some(funding) = config.get("funding")
+            && !shirabe_php_shim::empty(funding)
+            && let PhpMixed::List(list) = funding
+        {
+            let funding_vec: Vec<IndexMap<String, PhpMixed>> = list
+                .iter()
+                .filter_map(|v| match v.as_ref() {
+                    PhpMixed::Array(m) => {
+                        Some(m.iter().map(|(k, v)| (k.clone(), (**v).clone())).collect())
+                    }
+                    _ => None,
+                })
+                .collect();
+            package.complete_mut().set_funding(funding_vec);
         }
 
         if let Some(abandoned) = config.get("abandoned") {
             package.complete_mut().set_abandoned(abandoned.clone());
         }
 
-        if self.load_options {
-            if let Some(transport_options) = config.get("transport-options") {
-                let options = php_to_map(transport_options);
-                package.package_mut().set_transport_options(options);
-            }
+        if self.load_options
+            && let Some(transport_options) = config.get("transport-options")
+        {
+            let options = php_to_map(transport_options);
+            package.package_mut().set_transport_options(options);
         }
 
         let alias_normalized = self.get_branch_alias(config)?;
-        if let Some(alias_normalized) = alias_normalized {
-            if !alias_normalized.is_empty() {
-                let pretty_alias = Preg::replace(r"{(\.9{7})+}", ".x", &alias_normalized);
+        if let Some(alias_normalized) = alias_normalized
+            && !alias_normalized.is_empty()
+        {
+            let pretty_alias = Preg::replace(r"{(\.9{7})+}", ".x", &alias_normalized);
 
-                return Ok(match package {
-                    CompleteOrRootPackage::Root(root) => RootAliasPackageHandle::new(
-                        RootPackageHandle::from_root_package(root),
-                        alias_normalized,
-                        pretty_alias,
-                    )
-                    .into(),
-                    CompleteOrRootPackage::Complete(complete) => CompleteAliasPackageHandle::new(
-                        CompletePackageHandle::from_complete_package(complete),
-                        alias_normalized,
-                        pretty_alias,
-                    )
-                    .into(),
-                });
-            }
+            return Ok(match package {
+                CompleteOrRootPackage::Root(root) => RootAliasPackageHandle::new(
+                    RootPackageHandle::from_root_package(root),
+                    alias_normalized,
+                    pretty_alias,
+                )
+                .into(),
+                CompleteOrRootPackage::Complete(complete) => CompleteAliasPackageHandle::new(
+                    CompletePackageHandle::from_complete_package(complete),
+                    alias_normalized,
+                    pretty_alias,
+                )
+                .into(),
+            });
         }
 
         Ok(package.into_handle())
@@ -773,11 +765,11 @@ impl ArrayLoader {
                             let entry = (target.clone(), link);
                             link_cache
                                 .entry(name.clone())
-                                .or_insert_with(IndexMap::new)
+                                .or_default()
                                 .entry(r#type.to_string())
-                                .or_insert_with(IndexMap::new)
+                                .or_default()
                                 .entry(target.clone())
-                                .or_insert_with(IndexMap::new)
+                                .or_default()
                                 .insert(constraint_str.clone(), entry.clone());
                             entry
                         };
@@ -940,10 +932,10 @@ impl ArrayLoader {
                 let target_prefix = self
                     .version_parser
                     .parse_numeric_alias_prefix(&target_branch);
-                if let (Some(sp), Some(tp)) = (source_prefix.as_ref(), target_prefix.as_ref()) {
-                    if stripos(tp, sp) != Some(0) {
-                        continue;
-                    }
+                if let (Some(sp), Some(tp)) = (source_prefix.as_ref(), target_prefix.as_ref())
+                    && stripos(tp, sp) != Some(0)
+                {
+                    continue;
                 }
 
                 return Ok(Some(validated_target_branch));
diff --git a/crates/shirabe/src/package/loader/root_package_loader.rs b/crates/shirabe/src/package/loader/root_package_loader.rs
index 92f2be0..2d3bd0a 100644
--- a/crates/shirabe/src/package/loader/root_package_loader.rs
+++ b/crates/shirabe/src/package/loader/root_package_loader.rs
@@ -221,17 +221,17 @@ impl RootPackageLoader {
         }
 
         for link_type in SUPPORTED_LINK_TYPES.keys() {
-            if let Some(section) = config.get(*link_type) {
-                if let Some(section_map) = section.as_array() {
-                    for (link_name, _constraint) in section_map {
-                        if let Some(err) =
-                            ValidatingArrayLoader::has_package_naming_error(link_name, true)
-                        {
-                            return Err(anyhow::anyhow!(RuntimeException {
-                                message: format!("{}.{}", link_type, err),
-                                code: 0,
-                            }));
-                        }
+            if let Some(section) = config.get(*link_type)
+                && let Some(section_map) = section.as_array()
+            {
+                for (link_name, _constraint) in section_map {
+                    if let Some(err) =
+                        ValidatingArrayLoader::has_package_naming_error(link_name, true)
+                    {
+                        return Err(anyhow::anyhow!(RuntimeException {
+                            message: format!("{}.{}", link_type, err),
+                            code: 0,
+                        }));
                     }
                 }
             }
@@ -392,14 +392,14 @@ impl RootPackageLoader {
         for (req_name, req_version) in requires {
             let req_version = Preg::replace(r"^([^,\s@]+) as .+$", "$1", req_version);
             let mut m: IndexMap<CaptureKey, String> = IndexMap::new();
-            if Preg::is_match3(r"^[^,\s@]+?#([a-f0-9]+)$", &req_version, Some(&mut m)) {
-                if VersionParser::parse_stability(&req_version) == "dev" {
-                    let name = strtolower(req_name);
-                    references.insert(
-                        name,
-                        m.get(&CaptureKey::ByIndex(1)).cloned().unwrap_or_default(),
-                    );
-                }
+            if Preg::is_match3(r"^[^,\s@]+?#([a-f0-9]+)$", &req_version, Some(&mut m))
+                && VersionParser::parse_stability(&req_version) == "dev"
+            {
+                let name = strtolower(req_name);
+                references.insert(
+                    name,
+                    m.get(&CaptureKey::ByIndex(1)).cloned().unwrap_or_default(),
+                );
             }
         }
         references
diff --git a/crates/shirabe/src/package/loader/validating_array_loader.rs b/crates/shirabe/src/package/loader/validating_array_loader.rs
index dd2642e..490c0a9 100644
--- a/crates/shirabe/src/package/loader/validating_array_loader.rs
+++ b/crates/shirabe/src/package/loader/validating_array_loader.rs
@@ -43,9 +43,9 @@ impl ValidatingArrayLoader {
         parser: Option<VersionParser>,
         flags: i64,
     ) -> Self {
-        let version_parser = parser.unwrap_or_else(|| VersionParser::new());
+        let version_parser = parser.unwrap_or_default();
 
-        if strict_name != true {
+        if !strict_name {
             trigger_error(
                 "$strictName must be set to true in ValidatingArrayLoader's constructor as of 2.2, and it will be removed in 3.0",
                 E_USER_DEPRECATED,
@@ -72,21 +72,21 @@ impl ValidatingArrayLoader {
         self.config = config.clone();
 
         self.validate_string("name", true);
-        if let Some(name_val) = config.get("name").and_then(|v| v.as_string()) {
-            if let Some(err) = Self::has_package_naming_error(name_val, false) {
-                self.errors.push(format!("name : {}", err));
-            }
+        if let Some(name_val) = config.get("name").and_then(|v| v.as_string())
+            && let Some(err) = Self::has_package_naming_error(name_val, false)
+        {
+            self.errors.push(format!("name : {}", err));
         }
 
         if self.config.contains_key("version") {
             let version_val = self.config["version"].clone();
-            if !is_scalar(&*version_val) {
+            if !is_scalar(&version_val) {
                 self.validate_string("version", false);
             } else {
-                if !is_string(&*version_val) {
+                if !is_string(&version_val) {
                     self.config.insert(
                         "version".to_string(),
-                        Box::new(PhpMixed::String(php_to_string(&*version_val))),
+                        Box::new(PhpMixed::String(php_to_string(&version_val))),
                     );
                 }
                 let version_str = self
@@ -111,36 +111,35 @@ impl ValidatingArrayLoader {
             .get("config")
             .and_then(|v| v.as_array())
             .cloned()
+            && let Some(platform_val) = config_section.get("platform")
         {
-            if let Some(platform_val) = config_section.get("platform") {
-                let platform_array: IndexMap<String, Box<PhpMixed>> = match platform_val.as_ref() {
-                    PhpMixed::Array(m) => m.clone(),
-                    other => {
-                        let mut m = IndexMap::new();
-                        m.insert("0".to_string(), Box::new(other.clone()));
-                        m
-                    }
-                };
-                for (key, platform) in &platform_array {
-                    if let PhpMixed::Bool(false) = platform.as_ref() {
-                        continue;
-                    }
-                    if !is_string(platform) {
-                        self.errors.push(format!(
-                            "config.platform.{} : invalid value ({} {}): expected string or false",
-                            key,
-                            get_debug_type(platform),
-                            var_export(platform, true)
-                        ));
-                        continue;
-                    }
-                    let platform_str = platform.as_string().unwrap_or("").to_string();
-                    if let Err(e) = self.version_parser.normalize(&platform_str, None) {
-                        self.errors.push(format!(
-                            "config.platform.{} : invalid value ({}): {}",
-                            key, platform_str, e
-                        ));
-                    }
+            let platform_array: IndexMap<String, Box<PhpMixed>> = match platform_val.as_ref() {
+                PhpMixed::Array(m) => m.clone(),
+                other => {
+                    let mut m = IndexMap::new();
+                    m.insert("0".to_string(), Box::new(other.clone()));
+                    m
+                }
+            };
+            for (key, platform) in &platform_array {
+                if let PhpMixed::Bool(false) = platform.as_ref() {
+                    continue;
+                }
+                if !is_string(platform) {
+                    self.errors.push(format!(
+                        "config.platform.{} : invalid value ({} {}): expected string or false",
+                        key,
+                        get_debug_type(platform),
+                        var_export(platform, true)
+                    ));
+                    continue;
+                }
+                let platform_str = platform.as_string().unwrap_or("").to_string();
+                if let Err(e) = self.version_parser.normalize(&platform_str, None) {
+                    self.errors.push(format!(
+                        "config.platform.{} : invalid value ({}): {}",
+                        key, platform_str, e
+                    ));
                 }
             }
         }
@@ -150,7 +149,7 @@ impl ValidatingArrayLoader {
         self.validate_array("extra", false);
 
         if self.config.contains_key("bin") {
-            if is_string(&*self.config["bin"]) {
+            if is_string(&self.config["bin"]) {
                 self.validate_string("bin", false);
             } else {
                 self.validate_flat_array("bin", None, false);
@@ -181,7 +180,7 @@ impl ValidatingArrayLoader {
         if self.config.contains_key("license") {
             let license_val = self.config["license"].clone();
             // validate main data types
-            if is_array(&*license_val) || is_string(&*license_val) {
+            if is_array(&license_val) || is_string(&license_val) {
                 let mut licenses: IndexMap<String, Box<PhpMixed>> = match license_val.as_ref() {
                     PhpMixed::Array(m) => m.clone(),
                     other => {
@@ -194,7 +193,7 @@ impl ValidatingArrayLoader {
                 let license_keys: Vec<String> = licenses.keys().cloned().collect();
                 for index in &license_keys {
                     let license = licenses[index].clone();
-                    if !is_string(&*license) {
+                    if !is_string(&license) {
                         self.warnings.push(format!(
                             "License {} should be a string.",
                             PhpMixed::String(json_encode(&*license).unwrap_or_default()),
@@ -264,11 +263,11 @@ impl ValidatingArrayLoader {
                 .unwrap_or_default();
             for key in &author_keys {
                 let author = self.config["authors"].as_array().unwrap()[key].clone();
-                if !is_array(&*author) {
+                if !is_array(&author) {
                     self.errors.push(format!(
                         "authors.{} : should be an array, {} given",
                         key,
-                        get_debug_type(&*author)
+                        get_debug_type(&author)
                     ));
                     if let Some(PhpMixed::Array(m)) =
                         self.config.get_mut("authors").map(|v| v.as_mut())
@@ -279,21 +278,19 @@ impl ValidatingArrayLoader {
                 }
                 for author_data in ["homepage", "email", "name", "role"] {
                     let val_opt = author.as_array().and_then(|m| m.get(author_data)).cloned();
-                    if let Some(val) = val_opt {
-                        if !is_string(&*val) {
-                            self.errors.push(format!(
-                                "authors.{}.{} : invalid value, must be a string",
-                                key, author_data
-                            ));
-                            if let Some(PhpMixed::Array(authors)) =
-                                self.config.get_mut("authors").map(|v| v.as_mut())
-                            {
-                                if let Some(author_entry) = authors.get_mut(key) {
-                                    if let PhpMixed::Array(am) = author_entry.as_mut() {
-                                        am.shift_remove(author_data);
-                                    }
-                                }
-                            }
+                    if let Some(val) = val_opt
+                        && !is_string(&val)
+                    {
+                        self.errors.push(format!(
+                            "authors.{}.{} : invalid value, must be a string",
+                            key, author_data
+                        ));
+                        if let Some(PhpMixed::Array(authors)) =
+                            self.config.get_mut("authors").map(|v| v.as_mut())
+                            && let Some(author_entry) = authors.get_mut(key)
+                            && let PhpMixed::Array(am) = author_entry.as_mut()
+                        {
+                            am.shift_remove(author_data);
                         }
                     }
                 }
@@ -302,21 +299,19 @@ impl ValidatingArrayLoader {
                     .and_then(|m| m.get("homepage"))
                     .and_then(|v| v.as_string())
                     .map(|s| s.to_string());
-                if let Some(homepage_str) = homepage {
-                    if !self.filter_url(&homepage_str, &["http", "https"]) {
-                        self.warnings.push(format!(
-                            "authors.{}.homepage : invalid value ({}), must be an http/https URL",
-                            key, homepage_str
-                        ));
-                        if let Some(PhpMixed::Array(authors)) =
-                            self.config.get_mut("authors").map(|v| v.as_mut())
-                        {
-                            if let Some(author_entry) = authors.get_mut(key) {
-                                if let PhpMixed::Array(am) = author_entry.as_mut() {
-                                    am.shift_remove("homepage");
-                                }
-                            }
-                        }
+                if let Some(homepage_str) = homepage
+                    && !self.filter_url(&homepage_str, &["http", "https"])
+                {
+                    self.warnings.push(format!(
+                        "authors.{}.homepage : invalid value ({}), must be an http/https URL",
+                        key, homepage_str
+                    ));
+                    if let Some(PhpMixed::Array(authors)) =
+                        self.config.get_mut("authors").map(|v| v.as_mut())
+                        && let Some(author_entry) = authors.get_mut(key)
+                        && let PhpMixed::Array(am) = author_entry.as_mut()
+                    {
+                        am.shift_remove("homepage");
                     }
                 }
                 let email = author
@@ -324,21 +319,19 @@ impl ValidatingArrayLoader {
                     .and_then(|m| m.get("email"))
                     .and_then(|v| v.as_string())
                     .map(|s| s.to_string());
-                if let Some(email_str) = email {
-                    if !filter_var(&email_str, FILTER_VALIDATE_EMAIL) {
-                        self.warnings.push(format!(
-                            "authors.{}.email : invalid value ({}), must be a valid email address",
-                            key, email_str
-                        ));
-                        if let Some(PhpMixed::Array(authors)) =
-                            self.config.get_mut("authors").map(|v| v.as_mut())
-                        {
-                            if let Some(author_entry) = authors.get_mut(key) {
-                                if let PhpMixed::Array(am) = author_entry.as_mut() {
-                                    am.shift_remove("email");
-                                }
-                            }
-                        }
+                if let Some(email_str) = email
+                    && !filter_var(&email_str, FILTER_VALIDATE_EMAIL)
+                {
+                    self.warnings.push(format!(
+                        "authors.{}.email : invalid value ({}), must be a valid email address",
+                        key, email_str
+                    ));
+                    if let Some(PhpMixed::Array(authors)) =
+                        self.config.get_mut("authors").map(|v| v.as_mut())
+                        && let Some(author_entry) = authors.get_mut(key)
+                        && let PhpMixed::Array(am) = author_entry.as_mut()
+                    {
+                        am.shift_remove("email");
                     }
                 }
                 let current_author_len = self
@@ -349,12 +342,11 @@ impl ValidatingArrayLoader {
                     .and_then(|v| v.as_array())
                     .map(|m| m.len())
                     .unwrap_or(0);
-                if current_author_len == 0 {
-                    if let Some(PhpMixed::Array(authors)) =
+                if current_author_len == 0
+                    && let Some(PhpMixed::Array(authors)) =
                         self.config.get_mut("authors").map(|v| v.as_mut())
-                    {
-                        authors.shift_remove(key);
-                    }
+                {
+                    authors.shift_remove(key);
                 }
             }
             let authors_len = self
@@ -381,15 +373,15 @@ impl ValidatingArrayLoader {
                     .and_then(|v| v.as_array())
                     .and_then(|m| m.get(key))
                     .cloned();
-                if let Some(val) = val_opt {
-                    if !is_string(&*val) {
-                        self.errors
-                            .push(format!("support.{} : invalid value, must be a string", key));
-                        if let Some(PhpMixed::Array(support)) =
-                            self.config.get_mut("support").map(|v| v.as_mut())
-                        {
-                            support.shift_remove(key);
-                        }
+                if let Some(val) = val_opt
+                    && !is_string(&val)
+                {
+                    self.errors
+                        .push(format!("support.{} : invalid value, must be a string", key));
+                    if let Some(PhpMixed::Array(support)) =
+                        self.config.get_mut("support").map(|v| v.as_mut())
+                    {
+                        support.shift_remove(key);
                     }
                 }
             }
@@ -401,17 +393,17 @@ impl ValidatingArrayLoader {
                 .and_then(|m| m.get("email"))
                 .and_then(|v| v.as_string())
                 .map(|s| s.to_string());
-            if let Some(email_str) = support_email {
-                if !filter_var(&email_str, FILTER_VALIDATE_EMAIL) {
-                    self.warnings.push(format!(
-                        "support.email : invalid value ({}), must be a valid email address",
-                        email_str
-                    ));
-                    if let Some(PhpMixed::Array(support)) =
-                        self.config.get_mut("support").map(|v| v.as_mut())
-                    {
-                        support.shift_remove("email");
-                    }
+            if let Some(email_str) = support_email
+                && !filter_var(&email_str, FILTER_VALIDATE_EMAIL)
+            {
+                self.warnings.push(format!(
+                    "support.email : invalid value ({}), must be a valid email address",
+                    email_str
+                ));
+                if let Some(PhpMixed::Array(support)) =
+                    self.config.get_mut("support").map(|v| v.as_mut())
+                {
+                    support.shift_remove("email");
                 }
             }
 
@@ -422,17 +414,17 @@ impl ValidatingArrayLoader {
                 .and_then(|m| m.get("irc"))
                 .and_then(|v| v.as_string())
                 .map(|s| s.to_string());
-            if let Some(irc_str) = support_irc {
-                if !self.filter_url(&irc_str, &["irc", "ircs"]) {
-                    self.warnings.push(format!(
+            if let Some(irc_str) = support_irc
+                && !self.filter_url(&irc_str, &["irc", "ircs"])
+            {
+                self.warnings.push(format!(
                         "support.irc : invalid value ({}), must be a irc://<server>/<channel> or ircs:// URL",
                         irc_str
                     ));
-                    if let Some(PhpMixed::Array(support)) =
-                        self.config.get_mut("support").map(|v| v.as_mut())
-                    {
-                        support.shift_remove("irc");
-                    }
+                if let Some(PhpMixed::Array(support)) =
+                    self.config.get_mut("support").map(|v| v.as_mut())
+                {
+                    support.shift_remove("irc");
                 }
             }
 
@@ -446,17 +438,17 @@ impl ValidatingArrayLoader {
                     .and_then(|m| m.get(key))
                     .and_then(|v| v.as_string())
                     .map(|s| s.to_string());
-                if let Some(url_str) = url_opt {
-                    if !self.filter_url(&url_str, &["http", "https"]) {
-                        self.warnings.push(format!(
-                            "support.{} : invalid value ({}), must be an http/https URL",
-                            key, url_str
-                        ));
-                        if let Some(PhpMixed::Array(support)) =
-                            self.config.get_mut("support").map(|v| v.as_mut())
-                        {
-                            support.shift_remove(key);
-                        }
+                if let Some(url_str) = url_opt
+                    && !self.filter_url(&url_str, &["http", "https"])
+                {
+                    self.warnings.push(format!(
+                        "support.{} : invalid value ({}), must be an http/https URL",
+                        key, url_str
+                    ));
+                    if let Some(PhpMixed::Array(support)) =
+                        self.config.get_mut("support").map(|v| v.as_mut())
+                    {
+                        support.shift_remove(key);
                     }
                 }
             }
@@ -476,11 +468,11 @@ impl ValidatingArrayLoader {
                 .unwrap_or_default();
             for key in &funding_keys {
                 let funding_option = self.config["funding"].as_array().unwrap()[key].clone();
-                if !is_array(&*funding_option) {
+                if !is_array(&funding_option) {
                     self.errors.push(format!(
                         "funding.{} : should be an array, {} given",
                         key,
-                        get_debug_type(&*funding_option)
+                        get_debug_type(&funding_option)
                     ));
                     if let Some(PhpMixed::Array(funding)) =
                         self.config.get_mut("funding").map(|v| v.as_mut())
@@ -494,21 +486,19 @@ impl ValidatingArrayLoader {
                         .as_array()
                         .and_then(|m| m.get(funding_data))
                         .cloned();
-                    if let Some(val) = val_opt {
-                        if !is_string(&*val) {
-                            self.errors.push(format!(
-                                "funding.{}.{} : invalid value, must be a string",
-                                key, funding_data
-                            ));
-                            if let Some(PhpMixed::Array(funding)) =
-                                self.config.get_mut("funding").map(|v| v.as_mut())
-                            {
-                                if let Some(entry) = funding.get_mut(key) {
-                                    if let PhpMixed::Array(em) = entry.as_mut() {
-                                        em.shift_remove(funding_data);
-                                    }
-                                }
-                            }
+                    if let Some(val) = val_opt
+                        && !is_string(&val)
+                    {
+                        self.errors.push(format!(
+                            "funding.{}.{} : invalid value, must be a string",
+                            key, funding_data
+                        ));
+                        if let Some(PhpMixed::Array(funding)) =
+                            self.config.get_mut("funding").map(|v| v.as_mut())
+                            && let Some(entry) = funding.get_mut(key)
+                            && let PhpMixed::Array(em) = entry.as_mut()
+                        {
+                            em.shift_remove(funding_data);
                         }
                     }
                 }
@@ -517,21 +507,19 @@ impl ValidatingArrayLoader {
                     .and_then(|m| m.get("url"))
                     .and_then(|v| v.as_string())
                     .map(|s| s.to_string());
-                if let Some(url_str) = url {
-                    if !self.filter_url(&url_str, &["http", "https"]) {
-                        self.warnings.push(format!(
-                            "funding.{}.url : invalid value ({}), must be an http/https URL",
-                            key, url_str
-                        ));
-                        if let Some(PhpMixed::Array(funding)) =
-                            self.config.get_mut("funding").map(|v| v.as_mut())
-                        {
-                            if let Some(entry) = funding.get_mut(key) {
-                                if let PhpMixed::Array(em) = entry.as_mut() {
-                                    em.shift_remove("url");
-                                }
-                            }
-                        }
+                if let Some(url_str) = url
+                    && !self.filter_url(&url_str, &["http", "https"])
+                {
+                    self.warnings.push(format!(
+                        "funding.{}.url : invalid value ({}), must be an http/https URL",
+                        key, url_str
+                    ));
+                    if let Some(PhpMixed::Array(funding)) =
+                        self.config.get_mut("funding").map(|v| v.as_mut())
+                        && let Some(entry) = funding.get_mut(key)
+                        && let PhpMixed::Array(em) = entry.as_mut()
+                    {
+                        em.shift_remove("url");
                     }
                 }
                 let entry_empty = self
@@ -542,12 +530,11 @@ impl ValidatingArrayLoader {
                     .and_then(|v| v.as_array())
                     .map(|m| m.is_empty())
                     .unwrap_or(true);
-                if entry_empty {
-                    if let Some(PhpMixed::Array(funding)) =
+                if entry_empty
+                    && let Some(PhpMixed::Array(funding)) =
                         self.config.get_mut("funding").map(|v| v.as_mut())
-                    {
-                        funding.shift_remove(key);
-                    }
+                {
+                    funding.shift_remove(key);
                 }
             }
             if Self::is_empty_array(self.config.get("funding")) {
@@ -576,62 +563,63 @@ impl ValidatingArrayLoader {
                         _ => IndexMap::new(),
                     };
 
-                if let Some(v) = php_ext.get("extension-name").cloned() {
-                    if !is_string(&*v) {
-                        self.errors.push(format!(
-                            "php-ext.extension-name : should be a string, {} given",
-                            get_debug_type(&*v)
-                        ));
-                        php_ext.shift_remove("extension-name");
-                    }
+                if let Some(v) = php_ext.get("extension-name").cloned()
+                    && !is_string(&v)
+                {
+                    self.errors.push(format!(
+                        "php-ext.extension-name : should be a string, {} given",
+                        get_debug_type(&v)
+                    ));
+                    php_ext.shift_remove("extension-name");
                 }
 
-                if let Some(v) = php_ext.get("priority").cloned() {
-                    if !is_int(&*v) {
-                        self.errors.push(format!(
-                            "php-ext.priority : should be an integer, {} given",
-                            get_debug_type(&*v)
-                        ));
-                        php_ext.shift_remove("priority");
-                    }
+                if let Some(v) = php_ext.get("priority").cloned()
+                    && !is_int(&v)
+                {
+                    self.errors.push(format!(
+                        "php-ext.priority : should be an integer, {} given",
+                        get_debug_type(&v)
+                    ));
+                    php_ext.shift_remove("priority");
                 }
 
-                if let Some(v) = php_ext.get("support-zts").cloned() {
-                    if !is_bool(&*v) {
-                        self.errors.push(format!(
-                            "php-ext.support-zts : should be a boolean, {} given",
-                            get_debug_type(&*v)
-                        ));
-                        php_ext.shift_remove("support-zts");
-                    }
+                if let Some(v) = php_ext.get("support-zts").cloned()
+                    && !is_bool(&v)
+                {
+                    self.errors.push(format!(
+                        "php-ext.support-zts : should be a boolean, {} given",
+                        get_debug_type(&v)
+                    ));
+                    php_ext.shift_remove("support-zts");
                 }
 
-                if let Some(v) = php_ext.get("support-nts").cloned() {
-                    if !is_bool(&*v) {
-                        self.errors.push(format!(
-                            "php-ext.support-nts : should be a boolean, {} given",
-                            get_debug_type(&*v)
-                        ));
-                        php_ext.shift_remove("support-nts");
-                    }
+                if let Some(v) = php_ext.get("support-nts").cloned()
+                    && !is_bool(&v)
+                {
+                    self.errors.push(format!(
+                        "php-ext.support-nts : should be a boolean, {} given",
+                        get_debug_type(&v)
+                    ));
+                    php_ext.shift_remove("support-nts");
                 }
 
-                if let Some(v) = php_ext.get("build-path").cloned() {
-                    if !is_string(&*v) && !matches!(v.as_ref(), PhpMixed::Null) {
-                        self.errors.push(format!(
-                            "php-ext.build-path : should be a string or null, {} given",
-                            get_debug_type(&*v)
-                        ));
-                        php_ext.shift_remove("build-path");
-                    }
+                if let Some(v) = php_ext.get("build-path").cloned()
+                    && !is_string(&v)
+                    && !matches!(v.as_ref(), PhpMixed::Null)
+                {
+                    self.errors.push(format!(
+                        "php-ext.build-path : should be a string or null, {} given",
+                        get_debug_type(&v)
+                    ));
+                    php_ext.shift_remove("build-path");
                 }
 
                 if php_ext.contains_key("download-url-method") {
                     let v = php_ext["download-url-method"].clone();
-                    if !is_array(&*v) && !is_string(&*v) {
+                    if !is_array(&v) && !is_string(&v) {
                         self.errors.push(format!(
                             "php-ext.download-url-method : should be an array or a string, {} given",
-                            get_debug_type(&*v)
+                            get_debug_type(&v)
                         ));
                         php_ext.shift_remove("download-url-method");
                     } else {
@@ -641,7 +629,7 @@ impl ValidatingArrayLoader {
                             "pre-packaged-binary",
                         ];
                         let defined_download_url_methods: IndexMap<String, Box<PhpMixed>> =
-                            if is_array(&*v) {
+                            if is_array(&v) {
                                 v.as_array().unwrap().clone()
                             } else {
                                 let mut m = IndexMap::new();
@@ -657,11 +645,11 @@ impl ValidatingArrayLoader {
                             php_ext.shift_remove("download-url-method");
                         } else {
                             for (key, download_url_method) in &defined_download_url_methods {
-                                if !is_string(&**download_url_method) {
+                                if !is_string(download_url_method) {
                                     self.errors.push(format!(
                                         "php-ext.download-url-method.{} : should be a string, {} given",
                                         key,
-                                        get_debug_type(&**download_url_method)
+                                        get_debug_type(download_url_method)
                                     ));
                                     php_ext.shift_remove("download-url-method");
                                 } else if !valid_download_url_methods
@@ -695,11 +683,11 @@ impl ValidatingArrayLoader {
 
                     for field_name in ["os-families", "os-families-exclude"] {
                         if let Some(field_val) = php_ext.get(field_name).cloned() {
-                            if !is_array(&*field_val) {
+                            if !is_array(&field_val) {
                                 self.errors.push(format!(
                                     "php-ext.{} : should be an array, {} given",
                                     field_name,
-                                    get_debug_type(&*field_val)
+                                    get_debug_type(&field_val)
                                 ));
                                 php_ext.shift_remove(field_name);
                             } else if field_val.as_array().unwrap().is_empty() {
@@ -713,12 +701,12 @@ impl ValidatingArrayLoader {
                                     field_val.as_array().unwrap().keys().cloned().collect();
                                 for key in &field_keys {
                                     let os_family = field_val.as_array().unwrap()[key].clone();
-                                    if !is_string(&*os_family) {
+                                    if !is_string(&os_family) {
                                         self.errors.push(format!(
                                             "php-ext.{}.{} : should be a string, {} given",
                                             field_name,
                                             key,
-                                            get_debug_type(&*os_family)
+                                            get_debug_type(&os_family)
                                         ));
                                         if let Some(PhpMixed::Array(arr)) =
                                             php_ext.get_mut(field_name).map(|v| v.as_mut())
@@ -757,10 +745,10 @@ impl ValidatingArrayLoader {
 
                 if php_ext.contains_key("configure-options") {
                     let configure_options = php_ext["configure-options"].clone();
-                    if !is_array(&*configure_options) {
+                    if !is_array(&configure_options) {
                         self.errors.push(format!(
                             "php-ext.configure-options : should be an array, {} given",
-                            get_debug_type(&*configure_options)
+                            get_debug_type(&configure_options)
                         ));
                         php_ext.shift_remove("configure-options");
                     } else {
@@ -772,11 +760,11 @@ impl ValidatingArrayLoader {
                             .collect();
                         for key in &configure_keys {
                             let option = configure_options.as_array().unwrap()[key].clone();
-                            if !is_array(&*option) {
+                            if !is_array(&option) {
                                 self.errors.push(format!(
                                     "php-ext.configure-options.{} : should be an array, {} given",
                                     key,
-                                    get_debug_type(&*option)
+                                    get_debug_type(&option)
                                 ));
                                 if let Some(PhpMixed::Array(arr)) =
                                     php_ext.get_mut("configure-options").map(|v| v.as_mut())
@@ -801,11 +789,11 @@ impl ValidatingArrayLoader {
                             }
 
                             let name_val = option_map["name"].clone();
-                            if !is_string(&*name_val) {
+                            if !is_string(&name_val) {
                                 self.errors.push(format!(
                                     "php-ext.configure-options.{}.name : should be a string, {} given",
                                     key,
-                                    get_debug_type(&*name_val)
+                                    get_debug_type(&name_val)
                                 ));
                                 if let Some(PhpMixed::Array(arr)) =
                                     php_ext.get_mut("configure-options").map(|v| v.as_mut())
@@ -815,41 +803,37 @@ impl ValidatingArrayLoader {
                                 continue;
                             }
 
-                            if let Some(needs_value) = option_map.get("needs-value").cloned() {
-                                if !is_bool(&*needs_value) {
-                                    self.errors.push(format!(
+                            if let Some(needs_value) = option_map.get("needs-value").cloned()
+                                && !is_bool(&needs_value)
+                            {
+                                self.errors.push(format!(
                                         "php-ext.configure-options.{}.needs-value : should be a boolean, {} given",
                                         key,
-                                        get_debug_type(&*needs_value)
+                                        get_debug_type(&needs_value)
                                     ));
-                                    if let Some(PhpMixed::Array(co)) =
-                                        php_ext.get_mut("configure-options").map(|v| v.as_mut())
-                                    {
-                                        if let Some(entry) = co.get_mut(key) {
-                                            if let PhpMixed::Array(em) = entry.as_mut() {
-                                                em.shift_remove("needs-value");
-                                            }
-                                        }
-                                    }
+                                if let Some(PhpMixed::Array(co)) =
+                                    php_ext.get_mut("configure-options").map(|v| v.as_mut())
+                                    && let Some(entry) = co.get_mut(key)
+                                    && let PhpMixed::Array(em) = entry.as_mut()
+                                {
+                                    em.shift_remove("needs-value");
                                 }
                             }
 
-                            if let Some(description) = option_map.get("description").cloned() {
-                                if !is_string(&*description) {
-                                    self.errors.push(format!(
+                            if let Some(description) = option_map.get("description").cloned()
+                                && !is_string(&description)
+                            {
+                                self.errors.push(format!(
                                         "php-ext.configure-options.{}.description : should be a string, {} given",
                                         key,
-                                        get_debug_type(&*description)
+                                        get_debug_type(&description)
                                     ));
-                                    if let Some(PhpMixed::Array(co)) =
-                                        php_ext.get_mut("configure-options").map(|v| v.as_mut())
-                                    {
-                                        if let Some(entry) = co.get_mut(key) {
-                                            if let PhpMixed::Array(em) = entry.as_mut() {
-                                                em.shift_remove("description");
-                                            }
-                                        }
-                                    }
+                                if let Some(PhpMixed::Array(co)) =
+                                    php_ext.get_mut("configure-options").map(|v| v.as_mut())
+                                    && let Some(entry) = co.get_mut(key)
+                                    && let PhpMixed::Array(em) = entry.as_mut()
+                                {
+                                    em.shift_remove("description");
                                 }
                             }
                         }
@@ -885,19 +869,19 @@ impl ValidatingArrayLoader {
                     .unwrap_or_default();
                 for (package, constraint) in &link_section {
                     let package = package.to_string();
-                    if let Some(name_val) = self.config.get("name").and_then(|v| v.as_string()) {
-                        if strcasecmp(&package, name_val) == 0 {
-                            self.errors.push(format!(
-                                "{}.{} : a package cannot set a {} on itself",
-                                link_type, package, link_type
-                            ));
-                            if let Some(PhpMixed::Array(arr)) =
-                                self.config.get_mut(link_type).map(|v| v.as_mut())
-                            {
-                                arr.shift_remove(&package);
-                            }
-                            continue;
+                    if let Some(name_val) = self.config.get("name").and_then(|v| v.as_string())
+                        && strcasecmp(&package, name_val) == 0
+                    {
+                        self.errors.push(format!(
+                            "{}.{} : a package cannot set a {} on itself",
+                            link_type, package, link_type
+                        ));
+                        if let Some(PhpMixed::Array(arr)) =
+                            self.config.get_mut(link_type).map(|v| v.as_mut())
+                        {
+                            arr.shift_remove(&package);
                         }
+                        continue;
                     }
                     if let Some(err) = Self::has_package_naming_error(&package, true) {
                         self.warnings.push(format!("{}.{}", link_type, err));
@@ -907,7 +891,7 @@ impl ValidatingArrayLoader {
                             link_type, package
                         ));
                     }
-                    if !is_string(&**constraint) {
+                    if !is_string(constraint) {
                         self.errors.push(format!(
                             "{}.{} : invalid value, must be a string containing a version constraint",
                             link_type, package
@@ -950,7 +934,7 @@ impl ValidatingArrayLoader {
                             && link_type == "require"
                             && link_constraint
                                 .as_constraint()
-                                .map_or(false, |c| ["==", "="].contains(&c.get_operator()))
+                                .is_some_and(|c| ["==", "="].contains(&c.get_operator()))
                             && AnyConstraint::from(SimpleConstraint::new(
                                 ">=".to_string(),
                                 "1.0.0.0-dev".to_string(),
@@ -1017,7 +1001,7 @@ impl ValidatingArrayLoader {
                 .cloned()
                 .unwrap_or_default();
             for (package, description) in &suggest_map {
-                if !is_string(&**description) {
+                if !is_string(description) {
                     self.errors.push(format!(
                         "suggest.{} : invalid value, must be a string describing why the package is suggested",
                         package
@@ -1076,16 +1060,16 @@ impl ValidatingArrayLoader {
                         arr.shift_remove(r#type);
                     }
                 }
-                if r#type == "psr-4" {
-                    if let Some(type_map) = type_config.as_array() {
-                        for (namespace, _dirs) in type_map {
-                            let ns_str = namespace.as_str();
-                            if ns_str != "" && substr(ns_str, -1, None) != "\\" {
-                                self.errors.push(format!(
+                if r#type == "psr-4"
+                    && let Some(type_map) = type_config.as_array()
+                {
+                    for (namespace, _dirs) in type_map {
+                        let ns_str = namespace.as_str();
+                        if !ns_str.is_empty() && substr(ns_str, -1, None) != "\\" {
+                            self.errors.push(format!(
                                     "autoload.psr-4 : invalid value ({}), namespaces must end with a namespace separator, should be {}\\\\",
                                     ns_str, ns_str
                                 ));
-                            }
                         }
                     }
                 }
@@ -1132,35 +1116,36 @@ impl ValidatingArrayLoader {
                     self.errors
                         .push(format!("{}.reference : must be present", src_type));
                 }
-                if let Some(type_val) = section.get("type") {
-                    if !is_string(&**type_val) {
-                        self.errors.push(format!(
-                            "{}.type : should be a string, {} given",
-                            src_type,
-                            get_debug_type(&**type_val)
-                        ));
-                    }
+                if let Some(type_val) = section.get("type")
+                    && !is_string(type_val)
+                {
+                    self.errors.push(format!(
+                        "{}.type : should be a string, {} given",
+                        src_type,
+                        get_debug_type(type_val)
+                    ));
                 }
-                if let Some(url_val) = section.get("url") {
-                    if !is_string(&**url_val) {
-                        self.errors.push(format!(
-                            "{}.url : should be a string, {} given",
-                            src_type,
-                            get_debug_type(&**url_val)
-                        ));
-                    }
+                if let Some(url_val) = section.get("url")
+                    && !is_string(url_val)
+                {
+                    self.errors.push(format!(
+                        "{}.url : should be a string, {} given",
+                        src_type,
+                        get_debug_type(url_val)
+                    ));
                 }
-                if let Some(ref_val) = section.get("reference") {
-                    if !is_string(&**ref_val) && !is_int(&**ref_val) {
-                        self.errors.push(format!(
-                            "{}.reference : should be a string or int, {} given",
-                            src_type,
-                            get_debug_type(&**ref_val)
-                        ));
-                    }
+                if let Some(ref_val) = section.get("reference")
+                    && !is_string(ref_val)
+                    && !is_int(ref_val)
+                {
+                    self.errors.push(format!(
+                        "{}.reference : should be a string or int, {} given",
+                        src_type,
+                        get_debug_type(ref_val)
+                    ));
                 }
                 if let Some(ref_val) = section.get("reference") {
-                    let ref_str = php_to_string(&**ref_val);
+                    let ref_str = php_to_string(ref_val);
                     if Preg::is_match("{^\\s*-}", &ref_str) {
                         self.errors.push(format!(
                             "{}.reference : must not start with a \"-\", \"{}\" given",
@@ -1169,7 +1154,7 @@ impl ValidatingArrayLoader {
                     }
                 }
                 if let Some(url_val) = section.get("url") {
-                    let url_str = php_to_string(&**url_val);
+                    let url_str = php_to_string(url_val);
                     if Preg::is_match("{^\\s*-}", &url_str) {
                         self.errors.push(format!(
                             "{}.url : must not start with a \"-\", \"{}\" given",
@@ -1195,28 +1180,26 @@ impl ValidatingArrayLoader {
             .unwrap_or(false);
         if has_branch_alias {
             let branch_alias_val = self.config["extra"].as_array().unwrap()["branch-alias"].clone();
-            if !is_array(&*branch_alias_val) {
+            if !is_array(&branch_alias_val) {
                 self.errors.push(
                     "extra.branch-alias : must be an array of versions => aliases".to_string(),
                 );
             } else {
                 let branch_alias_map = branch_alias_val.as_array().cloned().unwrap_or_default();
                 for (source_branch, target_branch) in &branch_alias_map {
-                    if !is_string(&**target_branch) {
+                    if !is_string(target_branch) {
                         self.warnings.push(format!(
                             "extra.branch-alias.{} : the target branch ({}) must be a string, \"{}\" received.",
                             source_branch,
                             json_encode(&**target_branch).unwrap_or_default(),
-                            get_debug_type(&**target_branch)
+                            get_debug_type(target_branch)
                         ));
                         if let Some(PhpMixed::Array(extra)) =
                             self.config.get_mut("extra").map(|v| v.as_mut())
+                            && let Some(ba) = extra.get_mut("branch-alias")
+                            && let PhpMixed::Array(bam) = ba.as_mut()
                         {
-                            if let Some(ba) = extra.get_mut("branch-alias") {
-                                if let PhpMixed::Array(bam) = ba.as_mut() {
-                                    bam.shift_remove(source_branch);
-                                }
-                            }
+                            bam.shift_remove(source_branch);
                         }
                         continue;
                     }
@@ -1231,12 +1214,10 @@ impl ValidatingArrayLoader {
                         ));
                         if let Some(PhpMixed::Array(extra)) =
                             self.config.get_mut("extra").map(|v| v.as_mut())
+                            && let Some(ba) = extra.get_mut("branch-alias")
+                            && let PhpMixed::Array(bam) = ba.as_mut()
                         {
-                            if let Some(ba) = extra.get_mut("branch-alias") {
-                                if let PhpMixed::Array(bam) = ba.as_mut() {
-                                    bam.shift_remove(source_branch);
-                                }
-                            }
+                            bam.shift_remove(source_branch);
                         }
                         continue;
                     }
@@ -1255,12 +1236,10 @@ impl ValidatingArrayLoader {
                         ));
                         if let Some(PhpMixed::Array(extra)) =
                             self.config.get_mut("extra").map(|v| v.as_mut())
+                            && let Some(ba) = extra.get_mut("branch-alias")
+                            && let PhpMixed::Array(bam) = ba.as_mut()
                         {
-                            if let Some(ba) = extra.get_mut("branch-alias") {
-                                if let PhpMixed::Array(bam) = ba.as_mut() {
-                                    bam.shift_remove(source_branch);
-                                }
-                            }
+                            bam.shift_remove(source_branch);
                         }
                         continue;
                     }
@@ -1272,21 +1251,19 @@ impl ValidatingArrayLoader {
                     let target_prefix = self
                         .version_parser
                         .parse_numeric_alias_prefix(&target_branch_str);
-                    if let (Some(sp), Some(tp)) = (source_prefix, target_prefix) {
-                        if !tp.to_lowercase().starts_with(&sp.to_lowercase()) {
-                            self.warnings.push(format!(
+                    if let (Some(sp), Some(tp)) = (source_prefix, target_prefix)
+                        && !tp.to_lowercase().starts_with(&sp.to_lowercase())
+                    {
+                        self.warnings.push(format!(
                                 "extra.branch-alias.{} : the target branch ({}) is not a valid numeric alias for this version",
                                 source_branch, target_branch_str
                             ));
-                            if let Some(PhpMixed::Array(extra)) =
-                                self.config.get_mut("extra").map(|v| v.as_mut())
-                            {
-                                if let Some(ba) = extra.get_mut("branch-alias") {
-                                    if let PhpMixed::Array(bam) = ba.as_mut() {
-                                        bam.shift_remove(source_branch);
-                                    }
-                                }
-                            }
+                        if let Some(PhpMixed::Array(extra)) =
+                            self.config.get_mut("extra").map(|v| v.as_mut())
+                            && let Some(ba) = extra.get_mut("branch-alias")
+                            && let PhpMixed::Array(bam) = ba.as_mut()
+                        {
+                            bam.shift_remove(source_branch);
                         }
                     }
                 }
@@ -1410,11 +1387,11 @@ impl ValidatingArrayLoader {
     }
 
     fn validate_string(&mut self, property: &str, mandatory: bool) -> bool {
-        if self.config.contains_key(property) && !is_string(&*self.config[property]) {
+        if self.config.contains_key(property) && !is_string(&self.config[property]) {
             self.errors.push(format!(
                 "{} : should be a string, {} given",
                 property,
-                get_debug_type(&*self.config[property])
+                get_debug_type(&self.config[property])
             ));
             self.config.shift_remove(property);
 
@@ -1425,7 +1402,8 @@ impl ValidatingArrayLoader {
             || trim(
                 self.config[property].as_string().unwrap_or(""),
                 Some(" \t\n\r\0\u{0B}"),
-            ) == "";
+            )
+            .is_empty();
         if is_empty {
             if mandatory {
                 self.errors.push(format!("{} : must be present", property));
@@ -1439,11 +1417,11 @@ impl ValidatingArrayLoader {
     }
 
     fn validate_array(&mut self, property: &str, mandatory: bool) -> bool {
-        if self.config.contains_key(property) && !is_array(&*self.config[property]) {
+        if self.config.contains_key(property) && !is_array(&self.config[property]) {
             self.errors.push(format!(
                 "{} : should be an array, {} given",
                 property,
-                get_debug_type(&*self.config[property])
+                get_debug_type(&self.config[property])
             ));
             self.config.shift_remove(property);
 
@@ -1486,12 +1464,12 @@ impl ValidatingArrayLoader {
             .map(|m| m.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
             .unwrap_or_default();
         for (key, value) in entries {
-            if !is_string(&*value) && !is_numeric(&*value) {
+            if !is_string(&value) && !is_numeric(&value) {
                 self.errors.push(format!(
                     "{}.{} : must be a string or int, {} given",
                     property,
                     key,
-                    get_debug_type(&*value)
+                    get_debug_type(&value)
                 ));
                 if let Some(PhpMixed::Array(arr)) =
                     self.config.get_mut(property).map(|v| v.as_mut())
@@ -1504,7 +1482,7 @@ impl ValidatingArrayLoader {
             }
 
             if let Some(regex_str) = regex {
-                let value_str = php_to_string(&*value);
+                let value_str = php_to_string(&value);
                 if !Preg::is_match(&format!("{{^{}$}}u", regex_str), &value_str) {
                     self.warnings.push(format!(
                         "{}.{} : invalid value ({}), must match {}",
@@ -1543,7 +1521,7 @@ impl ValidatingArrayLoader {
     }
 
     fn filter_url(&self, value: &str, schemes: &[&str]) -> bool {
-        if value == "" {
+        if value.is_empty() {
             return true;
         }