Introduces ability to include Carthage related dependencies when creating a project configuration file

Tests/XcodeGenKitTests/CarthageDependencyResolverTests.swift

@@ -0,0 +1,123 @@
+import ProjectSpec
+import Spectre
+import XCTest
+import PathKit
+@testable import XcodeGenKit
+
+class CarthageDependencyResolverTests: XCTestCase {
+
+    override func setUp() {
+
+    }
+
+    func testBaseBuildPath() {
+        describe {
+            $0.it("provides the default base build path") {
+                let resolver = CarthageDependencyResolver(project: makeTestProject())
+
+                try expect(resolver.baseBuildPath) == "Carthage/Build"
+            }
+
+            $0.it("provides the base build path specified by the project specs") {
+                let customPath = "MyCustomBuildPath/Test"
+                let options = SpecOptions(carthageBuildPath: customPath)
+                let resolver = CarthageDependencyResolver(project: makeTestProject(options: options))
+
+                try expect(resolver.baseBuildPath) == customPath
+            }
+        }
+    }
+
+    func testExecutablePath() {
+        describe {
+            $0.it("provides the default executable path for carthage") {
+                let resolver = CarthageDependencyResolver(project: makeTestProject())
+
+                try expect(resolver.executablePath) == "carthage"
+            }
+
+            $0.it("provides the executable path for carthage as specified by the project specs") {
+                let customPath = "MyCustomBuildPath/Test/carthage"
+                let options = SpecOptions(carthageExecutablePath: customPath)
+                let resolver = CarthageDependencyResolver(project: makeTestProject(options: options))
+
+                try expect(resolver.executablePath) == customPath
+            }
+        }
+    }
+    func testBuildPathForPlatform() {
+        describe {
+            $0.it("generates the build path for a given platform") {
+                let resolver = CarthageDependencyResolver(project: makeTestProject())
+                let allPlatforms = Platform.all
+                let expectedByPlatform: [Platform: String] = allPlatforms.reduce(into: [:], { result, next in
+                    result[next] = "\(resolver.baseBuildPath)/\(next.carthageDirectoryName)"
+                })
+
+                try allPlatforms.forEach { platform in
+                    try expect(expectedByPlatform[platform]) == resolver.buildPath(for: platform)
+                }
+            }
+        }
+    }
+
+    func testRelatedDependenciesForPlatform() {
+
+        let dependencyFixtureName = "CarthageTestFixture"
+        let carthageBuildPath = fixturePath + "TestProject/Carthage/Build"
+
+        describe {
+            $0.it("fetches related dependencies for a given platform, sorted alphabetically") {
+
+                let options = SpecOptions(carthageBuildPath: carthageBuildPath.string)
+                let resolver = CarthageDependencyResolver(project: makeTestProject(options: options))
+                let dependency = Dependency(type: .carthage(includeRelated: true), reference: dependencyFixtureName)
+                let expectedDependencies: [Platform: [String]] = [
+                    .macOS: ["DependencyFixtureB", "DependencyFixtureA", "CarthageTestFixture"],
+                    .watchOS: ["DependencyFixtureA", "DependencyFixtureB", "CarthageTestFixture"],
+                    .tvOS: ["CarthageTestFixture", "DependencyFixtureA", "DependencyFixtureB"],
+                    .iOS: ["CarthageTestFixture", "DependencyFixtureA", "DependencyFixtureB"]
+                ]
+
+                try Platform.all.forEach { platform in
+                    let expected = expectedDependencies[platform] ?? []
+                    let related = resolver.relatedDependencies(for: dependency, in: platform)
+                    try expect(related.map { $0.reference }) == expected.sorted(by: { $0 < $1 })
+                }
+            }
+
+            $0.it("returns the main dependency when no related dependencies are found") {
+                let resolver = CarthageDependencyResolver(project: makeTestProject())
+                let dependency = Dependency(type: .carthage(includeRelated: true), reference: dependencyFixtureName)
+
+                let related = resolver.relatedDependencies(for: dependency, in: .iOS)
+
+                try expect(related.map { $0.reference }) == [dependencyFixtureName]
+            }
+        }
+    }
+
+    func testDependenciesForTopLevelTarget() {
+        describe {
+            $0.it("fetches all carthage dependencies for a given target, sorted alphabetically") {
+                let unsortedDependencyReferences = ["RxSwift", "RxCocoa", "RxBlocking", "RxTest", "RxAtomic"]
+                let dependencies = unsortedDependencyReferences.map {
+                    Dependency(type: .carthage(includeRelated: false), reference: $0)
+                }
+                let nonCarthageDependencies = unsortedDependencyReferences.map { Dependency(type: .target, reference: $0) }
+                let target = Target(name: "1", type: .application, platform: .iOS, dependencies: dependencies + nonCarthageDependencies)
+                let resolver = CarthageDependencyResolver(project: makeTestProject(with: [target]))
+
+                let related = resolver.dependencies(for: target)
+
+                try expect(related) == dependencies.sorted(by: { $0.reference < $1.reference })
+            }
+        }
+    }
+    
+}
+
+private func makeTestProject(with targets: [Target] = [], options: SpecOptions = SpecOptions()) -> Project {
+    return Project(name: "Test Project", targets: targets, options: options)
+
+}

Tests/XcodeGenKitTests/ProjectGeneratorTests.swift

@@ -437,7 +437,7 @@ class ProjectGeneratorTests: XCTestCase {
                     dependencies: [
                         Dependency(type: .target, reference: iosFrameworkZ.name),
                         Dependency(type: .framework, reference: "FrameworkZ.framework"),
-                        Dependency(type: .carthage, reference: "CarthageZ"),
+                        Dependency(type: .carthage(includeRelated: false), reference: "CarthageZ"),
                     ]
                 )
                 expectedResourceFiles[staticLibrary.name] = Set()
@@ -461,10 +461,10 @@ class ProjectGeneratorTests: XCTestCase {
                     dependencies: [
                         Dependency(type: .target, reference: resourceBundle.name),
                         Dependency(type: .framework, reference: "FrameworkC.framework"),
-                        Dependency(type: .carthage, reference: "CarthageA"),
+                        Dependency(type: .carthage(includeRelated: false), reference: "CarthageA"),
                         // Statically linked, so don't embed into test
                         Dependency(type: .target, reference: staticLibrary.name),
-                        Dependency(type: .carthage, reference: "CarthageB", embed: false),
+                        Dependency(type: .carthage(includeRelated: false), reference: "CarthageB", embed: false),
                     ]
                 )
                 expectedResourceFiles[iosFrameworkA.name] = Set()
@@ -487,7 +487,7 @@ class ProjectGeneratorTests: XCTestCase {
                         Dependency(type: .framework, reference: "FrameworkD.framework"),
                         // Embedded into framework, so don't embed into test
                         Dependency(type: .framework, reference: "FrameworkE.framework", embed: true),
-                        Dependency(type: .carthage, reference: "CarthageC", embed: true),
+                        Dependency(type: .carthage(includeRelated: false), reference: "CarthageC", embed: true),
                         // Statically linked, so don't embed into test
                         Dependency(type: .framework, reference: "FrameworkF.framework", embed: false),
                     ]
@@ -517,7 +517,7 @@ class ProjectGeneratorTests: XCTestCase {
                     dependencies: [
                         Dependency(type: .target, reference: app.name),
                         Dependency(type: .target, reference: iosFrameworkB.name),
-                        Dependency(type: .carthage, reference: "CarthageD"),
+                        Dependency(type: .carthage(includeRelated: false), reference: "CarthageD"),
                     ],
                     directlyEmbedCarthageDependencies: false
                 )

Tests/XcodeGenKitTests/SourceGeneratorTests.swift

@@ -528,9 +528,9 @@ class SourceGeneratorTests: XCTestCase {
                 """
                 try createDirectories(directories)
 
-                let watchTarget = Target(name: "Watch", type: .watch2App, platform: .watchOS, sources: ["A"], dependencies: [Dependency(type: .carthage, reference: "Alamofire_watch")])
+                let watchTarget = Target(name: "Watch", type: .watch2App, platform: .watchOS, sources: ["A"], dependencies: [Dependency(type: .carthage(includeRelated: false), reference: "Alamofire_watch")])
                 let watchDependency = Dependency(type: .target, reference: "Watch")
-                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["A"], dependencies: [Dependency(type: .carthage, reference: "Alamofire"), watchDependency])
+                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["A"], dependencies: [Dependency(type: .carthage(includeRelated: false), reference: "Alamofire"), watchDependency])
                 let project = Project(basePath: directoryPath, name: "Test", targets: [target, watchTarget])
 
                 let pbxProj = try project.generatePbxProj()
@@ -549,7 +549,7 @@ class SourceGeneratorTests: XCTestCase {
                 """
                 try createDirectories(directories)
 
-                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["A", "P", "S"], dependencies: [Dependency(type: .carthage, reference: "Alamofire")])
+                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["A", "P", "S"], dependencies: [Dependency(type: .carthage(includeRelated: false), reference: "Alamofire")])
                 let project = Project(basePath: directoryPath, name: "Test", targets: [target])
 
                 let pbxProj = try project.generatePbxProj()
@@ -572,7 +572,7 @@ class SourceGeneratorTests: XCTestCase {
                 """
                 try createDirectories(directories)
 
-                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["Sources"], dependencies: [Dependency(type: .carthage, reference: "Alamofire")])
+                let target = Target(name: "Test", type: .application, platform: .iOS, sources: ["Sources"], dependencies: [Dependency(type: .carthage(includeRelated: false), reference: "Alamofire")])
                 let project = Project(basePath: directoryPath, name: "Test", targets: [target])
 
                 let pbxProj = try project.generatePbxProj()

Tests/XcodeGenKitTests/SpecLoadingTests.swift

@@ -263,14 +263,14 @@ class SpecLoadingTests: XCTestCase {
                 var targetDictionary = validTarget
                 targetDictionary["dependencies"] = [
                     ["target": "name", "embed": false],
-                    ["carthage": "name"],
+                    ["carthage": "name", "includeRelated": true],
                     ["framework": "path", "weak": true],
                     ["sdk": "Contacts.framework"],
                 ]
                 let target = try Target(name: "test", jsonDictionary: targetDictionary)
                 try expect(target.dependencies.count) == 4
                 try expect(target.dependencies[0]) == Dependency(type: .target, reference: "name", embed: false)
-                try expect(target.dependencies[1]) == Dependency(type: .carthage, reference: "name")
+                try expect(target.dependencies[1]) == Dependency(type: .carthage(includeRelated: true), reference: "name")
                 try expect(target.dependencies[2]) == Dependency(type: .framework, reference: "path", weakLink: true)
                 try expect(target.dependencies[3]) == Dependency(type: .sdk, reference: "Contacts.framework")
             }