fix(cocoapods): Resolve paths for all pods and dependencies

The previous implementation updated only the `externalSources` in the
lockfile by copying the Lockfile object and replacing it with resolved
paths. However, this shallow update was insufficient because the nested
pod dependencies still referened the original unresolved paths.

This commit reconstructs the entire lockfile structure using resolved
absolute paths for the external sources. This guarantess that all path
references within the lockfile are consistent and correctly resolved.

Signed-off-by: Onur Demirci <[email protected]>

Author: bs-ondem

plugins/package-managers/cocoapods/src/main/kotlin/CocoaPods.kt

@@ -134,17 +134,10 @@ class CocoaPods(override val descriptor: PluginDescriptor = CocoaPodsFactory.des
             val lockfileData = lockfile.readText().parseLockfile()
 
             // Resolve paths of external sources relative to the lockfile.
-            val lockfileWithResolvedPaths = lockfileData.copy(
-                externalSources = lockfileData.externalSources.mapValues { entry ->
-                    Lockfile.ExternalSource(
-                        entry.value.path?.let { lockfile.resolveSibling(it).path },
-                        entry.value.podspec?.let { lockfile.resolveSibling(it).path }
-                    )
-                }
-            )
+            val lockfileWithResolvedPaths = lockfileData.withResolvedPaths(lockfile)
 
             // Convert direct dependencies with version constraints to pods with resolved versions.
-            val dependencies = lockfileData.dependencies.mapNotNull {
+            val dependencies = lockfileWithResolvedPaths.dependencies.mapNotNull {
                 it.resolvedPod?.run {
                     lockfileWithResolvedPaths.Pod(
                         name,
@@ -169,3 +162,43 @@ class CocoaPods(override val descriptor: PluginDescriptor = CocoaPodsFactory.des
     override fun createPackageManagerResult(projectResults: Map<File, List<ProjectAnalyzerResult>>) =
         PackageManagerResult(projectResults, graphBuilder.build(), graphBuilder.packages())
 }
+
+/**
+ * Return a new [Lockfile] instance with all external source paths resolved relative to the given [lockfilePath].
+ */
+internal fun Lockfile.withResolvedPaths(lockfilePath: File): Lockfile {
+    val resolvedExternalSources = externalSources.mapValues { entry ->
+        Lockfile.ExternalSource(
+            entry.value.path?.let { lockfilePath.resolveSibling(it).path },
+            entry.value.podspec?.let { lockfilePath.resolveSibling(it).path }
+        )
+    }
+
+    val pods = mutableListOf<Lockfile.Pod>()
+    val dependencies = mutableListOf<Lockfile.Dependency>()
+
+    val lockFile = Lockfile(pods, dependencies, resolvedExternalSources, checkoutOptions)
+
+    this.pods.forEach { pod ->
+        val resolvedPod = lockFile.Pod(
+            pod.name,
+            pod.version,
+            pod.dependencies.map { dependency ->
+                lockFile.Dependency(
+                    dependency.name,
+                    dependency.versionConstraint
+                )
+            }
+        )
+
+        pods += resolvedPod
+    }
+
+    this.dependencies.forEach { dependency ->
+        val resolvedDependency = lockFile.Dependency(dependency.name, dependency.versionConstraint)
+
+        dependencies += resolvedDependency
+    }
+
+    return lockFile
+}