Zip Carthage refactor (#5080)

Author: paulb777

ZipBuilder/README.md

@@ -8,14 +8,14 @@ you can fix issues or dig in without having to dig too deep into the code.
 
 ## Zip Builder
 
-This is a small Swift Package Manager project that allows users to package an iOS Zip file of binary
+This is a Swift Package Manager project that allows users to package an iOS Zip file of binary
 packages.
 
 ### Requirements
 
 In order to build the Zip file, you will need:
 
-- Xcode 10.1
+- Xcode 11.0
 - CocoaPods
 - An internet connection to fetch CocoaPods
 

ZipBuilder/Sources/ZipBuilder/CarthageUtils.swift

@@ -22,6 +22,56 @@ import Foundation
 enum CarthageUtils {}
 
 extension CarthageUtils {
+  /// Package all required files for a Carthage release.
+  ///
+  /// - Parameters:
+  ///   - templateDir: The template project directory, contains the dummy Firebase library.
+  ///   - carthageJSONDir: Location of directory containing all JSON Carthage manifests.
+  ///   - artifacts: Release Artifacts from build.
+  ///   - rcNumber: The RC number.
+  /// - Returns: The path to the root of the Carthage installation.
+  static func packageCarthageRelease(templateDir: URL,
+                                     carthageJSONDir: URL,
+                                     artifacts: ZipBuilder.ReleaseArtifacts,
+                                     rcNumber: Int?) -> URL? {
+    guard let zipLocation = artifacts.carthageDir else { return nil }
+
+    do {
+      print("Creating Carthage release...")
+      let carthagePath =
+        zipLocation.deletingLastPathComponent().appendingPathComponent("carthage_build")
+      // Create a copy of the release directory since we'll be modifying it.
+      let fileManager = FileManager.default
+      fileManager.removeIfExists(at: carthagePath)
+      try fileManager.copyItem(at: zipLocation, to: carthagePath)
+
+      // Package the Carthage distribution with the current directory structure.
+      let carthageDir = zipLocation.deletingLastPathComponent().appendingPathComponent("carthage")
+      fileManager.removeIfExists(at: carthageDir)
+      var output = carthageDir.appendingPathComponent(artifacts.firebaseVersion)
+      if let rcNumber = args.rcNumber {
+        output.appendPathComponent("rc\(rcNumber)")
+      } else {
+        output.appendPathComponent("latest-non-rc")
+      }
+      try fileManager.createDirectory(at: output, withIntermediateDirectories: true)
+      generateCarthageRelease(fromPackagedDir: carthagePath,
+                              templateDir: templateDir,
+                              jsonDir: carthageJSONDir,
+                              artifacts: artifacts,
+                              outputDir: output)
+
+      // Remove the duplicated Carthage build directory.
+      fileManager.removeIfExists(at: carthagePath)
+      print("Done creating Carthage release! Files written to \(output)")
+
+      // Save the directory for later copying.
+      return carthageDir
+    } catch {
+      fatalError("Could not copy output directory for Carthage build: \(error)")
+    }
+  }
+
   /// Generates all required files for a Carthage release.
   ///
   /// - Parameters:
@@ -31,18 +81,19 @@ extension CarthageUtils {
   ///   - firebaseVersion: The version of the Firebase pod.
   ///   - coreDiagnosticsPath: The path to the Core Diagnostics framework built for Carthage.
   ///   - outputDir: The directory where all artifacts should be created.
-  static func generateCarthageRelease(fromPackagedDir packagedDir: URL,
-                                      templateDir: URL,
-                                      jsonDir: URL,
-                                      firebaseVersion: String,
-                                      coreDiagnosticsPath: URL,
-                                      outputDir: URL) {
+
+  private static func generateCarthageRelease(fromPackagedDir packagedDir: URL,
+                                              templateDir: URL,
+                                              jsonDir: URL,
+                                              artifacts: ZipBuilder.ReleaseArtifacts,
+                                              outputDir: URL) {
     let directories: [String]
     do {
       directories = try FileManager.default.contentsOfDirectory(atPath: packagedDir.path)
     } catch {
       fatalError("Could not get contents of Firebase directory to package Carthage build. \(error)")
     }
+    let firebaseVersion = artifacts.firebaseVersion
 
     // Loop through each directory available and package it as a separate Zip file.
     for product in directories {
@@ -51,23 +102,20 @@ extension CarthageUtils {
 
       // Parse the JSON file, ensure that we're not trying to overwrite a release.
       var jsonManifest = parseJSONFile(fromDir: jsonDir, product: product)
-      guard jsonManifest[firebaseVersion] == nil else {
-        print("Carthage release for \(product) \(firebaseVersion) already exists - skipping.")
-        continue
+      if !args.carthageSkipVersionCheck {
+        guard jsonManifest[firebaseVersion] == nil else {
+          print("Carthage release for \(product) \(firebaseVersion) already exists - skipping.")
+          continue
+        }
       }
 
-      // Find all the .frameworks in this directory.
-      let allContents: [String]
-      do {
-        allContents = try FileManager.default.contentsOfDirectory(atPath: fullPath.path)
-      } catch {
-        fatalError("Could not get contents of \(product) for Carthage build in order to add " +
-          "an Info.plist in each framework. \(error)")
+      // Make updates to all frameworks to make Carthage happy. We don't worry about xcframeworks
+      // here.
+      let allFileObjects = FileManager.default.enumerator(atPath: fullPath.path)?.allObjects
+      guard let allFiles = allFileObjects as? [String] else {
+        fatalError("Failed to get file list for Carthage construction at \(fullPath.path)")
       }
-
-      // Carthage will fail to install a framework if it doesn't have an Info.plist, even though
-      // they're not used for static frameworks. Generate one and write it to each framework.
-      let frameworks = allContents.filter { $0.hasSuffix(".framework") }
+      let frameworks = allFiles.filter { $0.hasSuffix(".framework") }
       for framework in frameworks {
         let plistPath = fullPath.appendingPathComponents([framework, "Info.plist"])
         // Drop the extension of the framework name.
@@ -93,17 +141,6 @@ extension CarthageUtils {
         } catch {
           fatalError("Could not copy \(noticesName) to FirebaseCore for Carthage build. \(error)")
         }
-
-        // Override the Core Diagnostics framework with one that includes the proper bit flipped.
-        let coreDiagnosticsFramework = Constants.coreDiagnosticsName + ".framework"
-        let destination = fullPath.appendingPathComponent(coreDiagnosticsFramework)
-        do {
-          // Remove the existing framework and replace it with the newly compiled one.
-          try FileManager.default.removeItem(at: destination)
-          try FileManager.default.copyItem(at: coreDiagnosticsPath, to: destination)
-        } catch {
-          fatalError("Could not replace \(coreDiagnosticsFramework) during Carthage build. \(error)")
-        }
       }
 
       // Hash the contents of the directory to get a unique name for Carthage.

ZipBuilder/Sources/ZipBuilder/CocoaPodUtils.swift

@@ -311,6 +311,15 @@ enum CocoaPodUtils {
     return Array(returnDeps)
   }
 
+  /// Get all transitive pod dependencies for a pod with subspecs merged.
+  /// - Returns: An array of Strings of pod names.
+  static func transitiveMasterPodDependencies(for podName: String,
+                                              in installedPods: [String: PodInfo]) -> [String] {
+    return Array(Set(transitivePodDependencies(for: podName, in: installedPods).map {
+      $0.components(separatedBy: "/")[0]
+    }))
+  }
+
   /// Get all transitive pod dependencies for a pod.
   /// - Returns: An array of dependencies with versions for a given pod.
   static func transitiveVersionedPodDependencies(for podName: String,

ZipBuilder/Sources/ZipBuilder/FirebaseBuilder.swift

@@ -35,47 +35,16 @@ struct FirebaseBuilder {
     do {
       let artifacts = try builder.buildAndAssembleFirebaseRelease(inProjectDir: projectDir)
       let firebaseVersion = artifacts.firebaseVersion
-      let location = artifacts.outputDir
+      let location = artifacts.zipDir
       print("Firebase \(firebaseVersion) directory is ready to be packaged: \(location)")
 
       // Package carthage if it's enabled.
       var carthageRoot: URL?
       if let carthageJSONDir = args.carthageDir {
-        do {
-          print("Creating Carthage release...")
-          // Create a copy of the release directory since we'll be modifying it.
-          let carthagePath =
-            location.deletingLastPathComponent().appendingPathComponent("carthage_build")
-          let fileManager = FileManager.default
-          fileManager.removeIfExists(at: carthagePath)
-          try fileManager.copyItem(at: location, to: carthagePath)
-
-          // Package the Carthage distribution with the current directory structure.
-          let carthageDir = location.deletingLastPathComponent().appendingPathComponent("carthage")
-          fileManager.removeIfExists(at: carthageDir)
-          var output = carthageDir.appendingPathComponent(firebaseVersion)
-          if let rcNumber = args.rcNumber {
-            output.appendPathComponent("rc\(rcNumber)")
-          } else {
-            output.appendPathComponent("latest-non-rc")
-          }
-          try fileManager.createDirectory(at: output, withIntermediateDirectories: true)
-          CarthageUtils.generateCarthageRelease(fromPackagedDir: carthagePath,
-                                                templateDir: args.templateDir,
-                                                jsonDir: carthageJSONDir,
-                                                firebaseVersion: firebaseVersion,
-                                                coreDiagnosticsPath: artifacts.carthageDiagnostics,
-                                                outputDir: output)
-
-          // Remove the duplicated Carthage build directory.
-          fileManager.removeIfExists(at: carthagePath)
-          print("Done creating Carthage release! Files written to \(output)")
-
-          // Save the directory for later copying.
-          carthageRoot = carthageDir
-        } catch {
-          fatalError("Could not copy output directory for Carthage build: \(error)")
-        }
+        carthageRoot = CarthageUtils.packageCarthageRelease(templateDir: args.templateDir,
+                                                            carthageJSONDir: carthageJSONDir,
+                                                            artifacts: artifacts,
+                                                            rcNumber: args.rcNumber)
       }
 
       // Prepare the release directory for zip packaging.