Merge branch 'xcframework-master'

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,31 +102,10 @@ 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
-      }
-
-      // 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)")
-      }
-
-      // 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") }
-      for framework in frameworks {
-        let plistPath = fullPath.appendingPathComponents([framework, "Info.plist"])
-        // Drop the extension of the framework name.
-        let plist = generatePlistContents(forName: framework.components(separatedBy: ".").first!)
-        do {
-          try plist.write(to: plistPath)
-        } catch {
-          fatalError("Could not copy plist for \(framework) for Carthage release. \(error)")
+      if !args.carthageSkipVersionCheck {
+        guard jsonManifest[firebaseVersion] == nil else {
+          print("Carthage release for \(product) \(firebaseVersion) already exists - skipping.")
+          continue
         }
       }
 
@@ -93,17 +123,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.
@@ -229,7 +248,7 @@ extension CarthageUtils {
     }
   }
 
-  private static func generatePlistContents(forName name: String) -> Data {
+  static func generatePlistContents(forName name: String) -> Data {
     let plist: [String: String] = ["CFBundleIdentifier": "com.firebase.Firebase",
                                    "CFBundleInfoDictionaryVersion": "6.0",
                                    "CFBundlePackageType": "FMWK",

ZipBuilder/Sources/ZipBuilder/CocoaPodUtils.swift

@@ -40,7 +40,8 @@ enum CocoaPodUtils {
   }
 
   /// Information associated with an installed pod.
-  struct PodInfo {
+  /// This is a class so that moduleMapContents can be updated via reference.
+  class PodInfo {
     /// The version of the generated pod.
     let version: String
 
@@ -49,6 +50,39 @@ enum CocoaPodUtils {
 
     /// The location of the pod on disk.
     let installedLocation: URL
+
+    /// Source pod flag.
+    let isSourcePod: Bool
+
+    /// Binary frameworks in this pod.
+    let binaryFrameworks: [URL]
+
+    /// Subspecs installed for this pod.
+    let subspecs: Set<String>
+
+    /// The contents of the module map for all frameworks associated with the pod.
+    var moduleMapContents: ModuleMapBuilder.ModuleMapContents?
+
+    init(version: String, dependencies: [String], installedLocation: URL, subspecs: Set<String>) {
+      self.version = version
+      self.dependencies = dependencies
+      self.installedLocation = installedLocation
+      self.subspecs = subspecs
+
+      // Get all the frameworks contained in this directory.
+      var binaryFrameworks: [URL] = []
+      if installedLocation != LaunchArgs.shared.localPodspecPath {
+        do {
+          binaryFrameworks = try FileManager.default.recursivelySearch(for: .frameworks,
+                                                                       in: installedLocation)
+        } catch {
+          fatalError("Cannot search for .framework files in Pods directory " +
+            "\(installedLocation): \(error)")
+        }
+      }
+      self.binaryFrameworks = binaryFrameworks
+      isSourcePod = binaryFrameworks == []
+    }
   }
 
   /// Executes the `pod cache clean --all` command to remove any cached CocoaPods.
@@ -86,11 +120,14 @@ enum CocoaPodUtils {
   ///   - pods: List of VersionedPods to install
   ///   - directory: Destination directory for the pods.
   ///   - customSpecRepos: Additional spec repos to check for installation.
+  ///   - forceStaticLibs: Force a static library pod install. For the module map construction, we want pod names not module
+  ///                      names in the generated OTHER_LD_FLAGS options.
   /// - Returns: A dictionary of PodInfo's keyed by the pod name.
   @discardableResult
   static func installPods(_ pods: [VersionedPod],
                           inDir directory: URL,
-                          customSpecRepos: [URL]? = nil) -> [String: PodInfo] {
+                          customSpecRepos: [URL]?,
+                          forceStaticLibs: Bool = false) -> [String: PodInfo] {
     let fileManager = FileManager.default
     // Ensure the directory exists, otherwise we can't install all subspecs.
     guard fileManager.directoryExists(at: directory) else {
@@ -105,7 +142,10 @@ enum CocoaPodUtils {
 
     // Attempt to write the Podfile to disk.
     do {
-      try writePodfile(for: pods, toDirectory: directory, customSpecRepos: customSpecRepos)
+      try writePodfile(for: pods,
+                       toDirectory: directory,
+                       customSpecRepos: customSpecRepos,
+                       forceStaticLibs: forceStaticLibs)
     } catch let FileManager.FileError.directoryNotFound(path) {
       fatalError("Failed to write Podfile with pods \(pods) at path \(path)")
     } catch let FileManager.FileError.writeToFileFailed(path, error) {
@@ -156,30 +196,49 @@ enum CocoaPodUtils {
         break
       }
       if let (pod, version) = detectVersion(fromLine: line) {
-        let corePod = pod.components(separatedBy: "/")[0]
-        currentPod = corePod.trimmingCharacters(in: quotes)
+        currentPod = pod.trimmingCharacters(in: quotes)
         pods[currentPod!] = version
       } else if let currentPod = currentPod {
         let matches = depRegex.matches(in: line, range: NSRange(location: 0, length: line.utf8.count))
         // Match something like - GTMSessionFetcher/Full (= 1.3.0)
         if let match = matches.first {
           let depLine = (line as NSString).substring(with: match.range(at: 0)) as String
           // Split spaces and subspecs.
-          let dep = depLine.components(separatedBy: [" ", "/"])[2].trimmingCharacters(in: quotes)
+          let dep = depLine.components(separatedBy: [" "])[2].trimmingCharacters(in: quotes)
           if dep != currentPod {
-            if deps[currentPod] == nil {
-              deps[currentPod] = Set()
-            }
-            deps[currentPod]?.insert(dep)
+            deps[currentPod, default: Set()].insert(dep)
           }
         }
       }
     }
+    // Organize the subspecs
+    var versions: [String: String] = [:]
+    var subspecs: [String: Set<String>] = [:]
+
+    for (podName, version) in pods {
+      let subspecArray = podName.components(separatedBy: "/")
+      if subspecArray.count == 1 || subspecArray[0] == "abseil" {
+        // Special case for abseil since it has two layers and no external deps.
+        versions[subspecArray[0]] = version
+      } else if subspecArray.count > 2 {
+        fatalError("Multi-layered subspecs are not supported - \(podName)")
+      } else {
+        if let previousVersion = versions[podName], version != previousVersion {
+          fatalError("Different installed versions for \(podName)." +
+            "\(version) versus \(previousVersion)")
+        } else {
+          let basePodName = subspecArray[0]
+          versions[basePodName] = version
+          subspecs[basePodName, default: Set()].insert(subspecArray[1])
+          deps[basePodName] = deps[basePodName, default: Set()].union(deps[podName] ?? Set())
+        }
+      }
+    }
 
     // Generate an InstalledPod for each Pod found.
     let podsDir = projectDir.appendingPathComponent("Pods")
     var installedPods: [String: PodInfo] = [:]
-    for (podName, version) in pods {
+    for (podName, version) in versions {
       var podDir = podsDir.appendingPathComponent(podName)
       // Make sure that pod got installed if it's not coming from a local podspec.
       if !FileManager.default.directoryExists(at: podDir) {
@@ -190,7 +249,8 @@ enum CocoaPodUtils {
         podDir = repoDir
       }
       let dependencies = [String](deps[podName] ?? [])
-      let podInfo = PodInfo(version: version, dependencies: dependencies, installedLocation: podDir)
+      let podInfo = PodInfo(version: version, dependencies: dependencies, installedLocation: podDir,
+                            subspecs: subspecs[podName] ?? Set())
       installedPods[podName] = podInfo
     }
     return installedPods
@@ -251,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,
@@ -300,7 +369,8 @@ enum CocoaPodUtils {
   /// Create the contents of a Podfile for an array of subspecs. This assumes the array of subspecs
   /// is not empty.
   private static func generatePodfile(for pods: [VersionedPod],
-                                      customSpecsRepos: [URL]? = nil) -> String {
+                                      customSpecsRepos: [URL]?,
+                                      forceStaticLibs: Bool) -> String {
     // Start assembling the Podfile.
     var podfile: String = ""
 
@@ -315,6 +385,13 @@ enum CocoaPodUtils {
       """ // Explicit newline above to ensure it's included in the String.
     }
 
+    if forceStaticLibs {
+      podfile += "  use_modular_headers!\n"
+    } else if LaunchArgs.shared.dynamic {
+      podfile += "  use_frameworks!\n"
+    } else {
+      podfile += "  use_frameworks! :linkage => :static\n"
+    }
     // Include the minimum iOS version.
     podfile += """
     platform :ios, '\(LaunchArgs.shared.minimumIOSVersion)'
@@ -367,15 +444,16 @@ enum CocoaPodUtils {
   /// "Podfile".
   private static func writePodfile(for pods: [VersionedPod],
                                    toDirectory directory: URL,
-                                   customSpecRepos: [URL]?) throws {
+                                   customSpecRepos: [URL]?,
+                                   forceStaticLibs: Bool) throws {
     guard FileManager.default.directoryExists(at: directory) else {
       // Throw an error so the caller can provide a better error message.
       throw FileManager.FileError.directoryNotFound(path: directory.path)
     }
 
     // Generate the full path of the Podfile and attempt to write it to disk.
     let path = directory.appendingPathComponent("Podfile")
-    let podfile = generatePodfile(for: pods, customSpecsRepos: customSpecRepos)
+    let podfile = generatePodfile(for: pods, customSpecsRepos: customSpecRepos, forceStaticLibs: forceStaticLibs)
     do {
       try podfile.write(toFile: path.path, atomically: true, encoding: .utf8)
     } catch {

ZipBuilder/Sources/ZipBuilder/FileManager+Utils.swift

@@ -101,8 +101,14 @@ extension FileManager {
     }
   }
 
-  // Enable a single unique temporary workspace per execution.
-  static let unique: String = UUID().uuidString
+  /// Enable a single unique temporary workspace per execution with a sortable and readable timestamp.
+  private static func timeStamp() -> String {
+    let formatter = DateFormatter()
+    formatter.dateFormat = "YYYY-MM-dd'T'HH-mm-ss"
+    return formatter.string(from: Date())
+  }
+
+  static let unique: String = timeStamp()
 
   /// Returns a deterministic path of a temporary directory for the given name. Note: This does
   /// *not* create the directory if it doesn't exist, merely generates the name for creation.