refactor(plugins): reduce nesting in collect_autoload_paths

Extract collect_psr_paths and collect_string_array_paths helpers to
address qlty nested-control-flow and function-complexity findings.

Author: sinemacula-ben

qlty-check/src/tool/php/composer.rs

@@ -264,10 +264,7 @@ impl Composer {
 
             let link = sandbox_dir.join(relative_path);
             if link.symlink_metadata().is_ok() {
-                debug!(
-                    "Skipping autoload symlink, path already exists: {:?}",
-                    link
-                );
+                debug!("Skipping autoload symlink, path already exists: {:?}", link);
                 continue;
             }
 
@@ -291,54 +288,63 @@ impl Composer {
         let mut paths = vec![];
 
         for section in &["autoload", "autoload-dev"] {
-            if let Some(autoload) = composer_json.get(section) {
-                for key in &["psr-4", "psr-0"] {
-                    if let Some(mappings) = autoload.get(key).and_then(|v| v.as_object()) {
-                        for (_, path_value) in mappings {
-                            match path_value {
-                                Value::String(s) if !s.is_empty() => {
-                                    paths.push(s.trim_end_matches('/').to_string());
-                                }
-                                Value::Array(arr) => {
-                                    for v in arr {
-                                        if let Some(s) = v.as_str() {
-                                            if !s.is_empty() {
-                                                paths.push(
-                                                    s.trim_end_matches('/').to_string(),
-                                                );
-                                            }
-                                        }
-                                    }
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
-                }
+            let Some(autoload) = composer_json.get(section) else {
+                continue;
+            };
 
-                if let Some(classmap) = autoload.get("classmap").and_then(|v| v.as_array()) {
-                    for v in classmap {
-                        if let Some(s) = v.as_str() {
-                            if !s.is_empty() {
-                                paths.push(s.trim_end_matches('/').to_string());
-                            }
-                        }
+            for key in &["psr-4", "psr-0"] {
+                if let Some(mappings) = autoload.get(key).and_then(|v| v.as_object()) {
+                    for (_, path_value) in mappings {
+                        Self::collect_psr_paths(path_value, &mut paths);
                     }
                 }
+            }
 
-                if let Some(files) = autoload.get("files").and_then(|v| v.as_array()) {
-                    for v in files {
-                        if let Some(s) = v.as_str() {
-                            if !s.is_empty() {
-                                paths.push(s.to_string());
-                            }
-                        }
-                    }
+            Self::collect_string_array_paths(autoload.get("classmap"), true, &mut paths);
+            Self::collect_string_array_paths(autoload.get("files"), false, &mut paths);
+        }
+
+        paths
+    }
+
+    fn collect_psr_paths(path_value: &Value, paths: &mut Vec<String>) {
+        match path_value {
+            Value::String(s) if !s.is_empty() => {
+                paths.push(s.trim_end_matches('/').to_string());
+            }
+            Value::Array(arr) => {
+                for s in arr
+                    .iter()
+                    .filter_map(|v| v.as_str())
+                    .filter(|s| !s.is_empty())
+                {
+                    paths.push(s.trim_end_matches('/').to_string());
                 }
             }
+            _ => {}
         }
+    }
 
-        paths
+    fn collect_string_array_paths(
+        value: Option<&Value>,
+        trim_trailing_slash: bool,
+        paths: &mut Vec<String>,
+    ) {
+        let Some(arr) = value.and_then(|v| v.as_array()) else {
+            return;
+        };
+
+        for s in arr
+            .iter()
+            .filter_map(|v| v.as_str())
+            .filter(|s| !s.is_empty())
+        {
+            if trim_trailing_slash {
+                paths.push(s.trim_end_matches('/').to_string());
+            } else {
+                paths.push(s.to_string());
+            }
+        }
     }
 }
 
@@ -802,8 +808,18 @@ pub mod test {
             Composer::create_autoload_symlinks(pkg)?;
 
             let sandbox_dir = PathBuf::from(pkg.directory());
-            assert!(sandbox_dir.join("app").symlink_metadata().unwrap().file_type().is_symlink());
-            assert!(sandbox_dir.join("tests").symlink_metadata().unwrap().file_type().is_symlink());
+            assert!(sandbox_dir
+                .join("app")
+                .symlink_metadata()
+                .unwrap()
+                .file_type()
+                .is_symlink());
+            assert!(sandbox_dir
+                .join("tests")
+                .symlink_metadata()
+                .unwrap()
+                .file_type()
+                .is_symlink());
             assert_eq!(
                 std::fs::read_link(sandbox_dir.join("app"))?,
                 project_dir.join("app")
@@ -878,7 +894,12 @@ pub mod test {
             Composer::create_autoload_symlinks(pkg)?;
 
             let sandbox_dir = PathBuf::from(pkg.directory());
-            assert!(sandbox_dir.join("app").symlink_metadata().unwrap().file_type().is_symlink());
+            assert!(sandbox_dir
+                .join("app")
+                .symlink_metadata()
+                .unwrap()
+                .file_type()
+                .is_symlink());
             assert!(!sandbox_dir.join("does-not-exist").exists());
 
             Ok(())

qlty-config/src/config/builder.rs

@@ -466,6 +466,7 @@ fn merge_enabled_plugins(existing: &EnabledPlugin, new: &EnabledPlugin) -> Enabl
         triggers: prioritize_new_array(&existing.triggers, &new.triggers),
         fetch: prioritize_new_array(&existing.fetch, &new.fetch),
         package_filters: prioritize_new_array(&existing.package_filters, &new.package_filters),
+        preserve_autoload: new.preserve_autoload || existing.preserve_autoload,
         affects_cache: prioritize_new_array(&existing.affects_cache, &new.affects_cache),
         extra_packages: prioritize_new_array(&existing.extra_packages, &new.extra_packages),
         drivers: prioritize_new_array(&existing.drivers, &new.drivers),
@@ -788,6 +789,7 @@ mod test {
                 path: "path1".to_string(),
             }],
             package_filters: vec!["filter1".to_string()],
+            preserve_autoload: false,
             affects_cache: vec!["cache1".to_string()],
             extra_packages: vec![ExtraPackage {
                 name: "pkg1".to_string(),
@@ -810,6 +812,7 @@ mod test {
                 path: "path2".to_string(),
             }],
             package_filters: vec!["filter2".to_string()],
+            preserve_autoload: false,
             affects_cache: vec!["cache2".to_string()],
             extra_packages: vec![ExtraPackage {
                 name: "pkg2".to_string(),
@@ -1060,6 +1063,7 @@ mod test {
                     path: "path1".to_string(),
                 }],
                 package_filters: vec!["filter1".to_string()],
+                preserve_autoload: false,
                 affects_cache: vec!["cache1".to_string()],
                 extra_packages: vec![ExtraPackage {
                     name: "pkg1".to_string(),
@@ -1081,6 +1085,7 @@ mod test {
                     path: "path2".to_string(),
                 }],
                 package_filters: vec!["filter2".to_string()],
+                preserve_autoload: false,
                 affects_cache: vec!["cache2".to_string()],
                 extra_packages: vec![ExtraPackage {
                     name: "pkg2".to_string(),