Automate copy-frameworks

Source/CarthageKit/Project.swift

@@ -1169,6 +1169,44 @@ public final class Project { // swiftlint:disable:this type_body_length
 				return incompatibilities.isEmpty ? .init(value: ()) : .init(error: .invalidResolvedCartfile(incompatibilities))
 			}
 	}
+
+    func findLinkedFrameworks(
+        for executableURL: URL,
+        existingFrameworksEnumerator: SignalProducer<URL, CarthageError>
+    ) -> SignalProducer<String, CarthageError> {
+        let existingFrameworksMap = existingFrameworksEnumerator
+            .filter { url in
+                // We need to filter out any static frameworks to not accidentally copy then for the dynamically linked ones.
+                let components = url.pathComponents
+                let staticFolderIndex = components.index(components.endIndex, offsetBy: -2)
+                return staticFolderIndex >= 0 && components[staticFolderIndex] != FrameworkType.staticFolderName
+            }
+            .reduce(into: [String: URL]()) { (map, frameworkURL) in
+                let name = frameworkURL.deletingPathExtension().lastPathComponent
+                map[name] = frameworkURL
+            }
+
+        return sharedLinkedFrameworks(for: executableURL).flatMap(.latest) { frameworks -> SignalProducer<String, CarthageError> in
+            if frameworks.isEmpty {
+                return .empty
+            }
+
+            return existingFrameworksMap.flatMap(.latest) {  builtFrameworks -> SignalProducer<String, CarthageError> in
+                return SignalProducer(frameworks).filterMap { builtFrameworks[$0]?.path }
+            }
+        }
+    }
+
+    /// Finds Carthage's frameworks that are linked against a given executable.
+    ///
+    /// - Parameters:
+    ///   - executableURL: Path to a executable of the Project. See `xcodebuild` settings `TARGET_BUILD_DIR` and `EXECUTABLE_PATH` for more info.
+    ///   - platform: Platform of the executable.
+    /// - Returns: Stream of Path for each linked framework for a given `platform` that was build by Carthage.
+    public func findLinkedFrameworks(for executableURL: URL, platform: Platform) -> SignalProducer<String, CarthageError> {
+        let frameworksDirectory = directoryURL.appendingPathComponent(platform.relativePath, isDirectory: true)
+        return findLinkedFrameworks(for: executableURL, existingFrameworksEnumerator: frameworksInDirectory(frameworksDirectory))
+    }
 }
 
 /// Creates symlink between the dependency build folder and the root build folder
@@ -1521,3 +1559,44 @@ public func cloneOrFetch(
 				}
 		}
 }
+
+/// Invokes otool -L for a given executable URL.
+///
+/// - Parameter executableURL: URL to a valid executable.
+/// - Returns: Array of the Shared Library ID that are linked against given executable (`Alamofire`, `Realm`, etc).
+/// System libraries and dylibs are omited.
+internal func sharedLinkedFrameworks(for executableURL: URL) -> SignalProducer<[String], CarthageError> {
+    return Task("/usr/bin/xcrun", arguments: ["otool", "-L", executableURL.path.spm_shellEscaped()])
+        .launch()
+        .mapError(CarthageError.taskError)
+        .ignoreTaskData()
+        .filterMap { data -> String? in
+            return String(data: data, encoding: .utf8)
+        }
+        .map(sharedLinkedFrameworkIDs(from:))
+}
+
+/// Stripping linked shared frameworks from
+/// @rpath/Alamofire.framework/Alamofire (compatibility version 1.0.0, current version 1.0.0)
+/// to Alamofire as well as filtering out system frameworks and various dylibs.
+/// Static frameworks and libraries won't show up here, so we can ignore them.
+///
+/// - Parameter input: Output of the otool -L
+/// - Returns: Array of Shared Framework IDs.
+internal func sharedLinkedFrameworkIDs(from input: String) -> [String] {
+    guard let regex = try? NSRegularExpression(pattern: "@rpath.*\\.framework\\/([\\w]+)") else {
+        return []
+    }
+    return input.components(separatedBy: "\n").compactMap { value in
+        let fullNSRange = NSRange(value.startIndex..<value.endIndex, in: value)
+        if
+            let match = regex.firstMatch(in: value, range: fullNSRange),
+            match.numberOfRanges > 1,
+            match.range(at: 1).length > 0
+        {
+            return Range(match.range(at: 1), in: value).map { String(value[$0]) }
+        }
+        return nil
+    }
+}
+

Source/carthage/CopyFrameworks.swift

@@ -155,6 +155,14 @@ private func targetBuildFolder() -> Result<URL, CarthageError> {
 		.map { URL(fileURLWithPath: $0, isDirectory: true) }
 }
 
+private func executablePath() -> Result<URL, CarthageError> {
+    return appropriateDestinationFolder().flatMap { url in
+        return getEnvironmentVariable("EXECUTABLE_PATH").map { path in
+            return url.appendingPathComponent(path)
+        }
+    }
+}
+
 private func frameworksFolder() -> Result<URL, CarthageError> {
 	return appropriateDestinationFolder()
 		.flatMap { url -> Result<URL, CarthageError> in
@@ -163,6 +171,11 @@ private func frameworksFolder() -> Result<URL, CarthageError> {
 		}
 }
 
+private func projectDirectory() -> Result<URL, CarthageError> {
+    return getEnvironmentVariable("PROJECT_FILE_PATH")
+        .map { URL(fileURLWithPath: $0, isDirectory: false).deletingLastPathComponent() }
+}
+
 private func validArchitectures() -> Result<[String], CarthageError> {
 	return getEnvironmentVariable("VALID_ARCHS").map { architectures -> [String] in
 		return architectures.components(separatedBy: " ")
@@ -175,7 +188,7 @@ private func buildActionIsArchiveOrInstall() -> Bool {
 }
 
 private func inputFiles() -> SignalProducer<String, CarthageError> {
-	return SignalProducer(values: scriptInputFiles(), scriptInputFileLists())
+	return SignalProducer(values: scriptInputFiles(), scriptInputFileLists(), inferredInputFiles())
 		.flatten(.merge)
 		.uniqueValues()
 }
@@ -213,3 +226,15 @@ private func scriptInputFileLists() -> SignalProducer<String, CarthageError> {
 		return .empty
 	}
 }
+
+private func inferredInputFiles() -> SignalProducer<String, CarthageError> {
+    if
+        let directory = projectDirectory().value,
+        let platformName = getEnvironmentVariable("PLATFORM_NAME").value,
+        let platform = BuildPlatform.from(string: platformName)?.platforms.first,
+        let executable = executablePath().value
+    {
+        return Project(directoryURL: directory).findLinkedFrameworks(for: executable, platform: platform)
+    }
+    return .empty
+}