2018-11-04 14:30:34 +03:00
|
|
|
import Foundation
|
2018-10-18 16:29:45 +03:00
|
|
|
import ProjectSpec
|
2019-06-07 23:36:48 +03:00
|
|
|
import XcodeProj
|
2020-01-07 16:20:16 +03:00
|
|
|
import PathKit
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2019-10-02 19:05:15 +03:00
|
|
|
private func suitableConfig(for type: ConfigType, in project: Project) -> Config {
|
2019-10-02 17:57:17 +03:00
|
|
|
if let defaultConfig = Config.defaultConfigs.first(where: { $0.type == type }),
|
|
|
|
project.configs.contains(defaultConfig) {
|
|
|
|
return defaultConfig
|
|
|
|
}
|
|
|
|
return project.configs.first { $0.type == type }!
|
|
|
|
}
|
|
|
|
|
2018-10-18 16:29:45 +03:00
|
|
|
public class SchemeGenerator {
|
|
|
|
|
|
|
|
let project: Project
|
|
|
|
let pbxProj: PBXProj
|
|
|
|
|
|
|
|
var defaultDebugConfig: Config {
|
2020-01-15 06:40:12 +03:00
|
|
|
suitableConfig(for: .debug, in: project)
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
var defaultReleaseConfig: Config {
|
2020-01-15 06:40:12 +03:00
|
|
|
suitableConfig(for: .release, in: project)
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public init(project: Project, pbxProj: PBXProj) {
|
|
|
|
self.project = project
|
|
|
|
self.pbxProj = pbxProj
|
|
|
|
}
|
|
|
|
|
2019-10-27 03:23:35 +03:00
|
|
|
private var projects: [ProjectReference: PBXProj] = [:]
|
|
|
|
|
|
|
|
func getPBXProj(from reference: ProjectReference) throws -> PBXProj {
|
|
|
|
if let cachedProject = projects[reference] {
|
|
|
|
return cachedProject
|
|
|
|
}
|
2020-01-07 16:20:16 +03:00
|
|
|
let pbxproj = try XcodeProj(path: project.basePath + Path(reference.path)).pbxproj
|
2019-10-27 03:23:35 +03:00
|
|
|
projects[reference] = pbxproj
|
|
|
|
return pbxproj
|
|
|
|
}
|
|
|
|
|
2018-10-18 16:29:45 +03:00
|
|
|
public func generateSchemes() throws -> [XCScheme] {
|
|
|
|
var xcschemes: [XCScheme] = []
|
|
|
|
|
|
|
|
for scheme in project.schemes {
|
|
|
|
let xcscheme = try generateScheme(scheme)
|
|
|
|
xcschemes.append(xcscheme)
|
|
|
|
}
|
|
|
|
|
|
|
|
for target in project.targets {
|
|
|
|
if let targetScheme = target.scheme {
|
|
|
|
if targetScheme.configVariants.isEmpty {
|
|
|
|
let schemeName = target.name
|
|
|
|
|
2019-10-02 19:05:15 +03:00
|
|
|
let debugConfig = suitableConfig(for: .debug, in: project)
|
|
|
|
let releaseConfig = suitableConfig(for: .release, in: project)
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2020-03-26 16:14:46 +03:00
|
|
|
let scheme = Scheme(
|
2018-10-18 16:29:45 +03:00
|
|
|
name: schemeName,
|
|
|
|
target: target,
|
|
|
|
targetScheme: targetScheme,
|
2020-03-26 16:14:46 +03:00
|
|
|
project: project,
|
2018-10-18 16:29:45 +03:00
|
|
|
debugConfig: debugConfig.name,
|
|
|
|
releaseConfig: releaseConfig.name
|
|
|
|
)
|
2020-03-26 16:14:46 +03:00
|
|
|
let xcscheme = try generateScheme(scheme, for: target)
|
2018-10-18 16:29:45 +03:00
|
|
|
xcschemes.append(xcscheme)
|
|
|
|
} else {
|
|
|
|
for configVariant in targetScheme.configVariants {
|
|
|
|
|
|
|
|
let schemeName = "\(target.name) \(configVariant)"
|
|
|
|
|
|
|
|
let debugConfig = project.configs
|
|
|
|
.first { $0.type == .debug && $0.name.contains(configVariant) }!
|
|
|
|
let releaseConfig = project.configs
|
|
|
|
.first { $0.type == .release && $0.name.contains(configVariant) }!
|
|
|
|
|
|
|
|
let scheme = Scheme(
|
|
|
|
name: schemeName,
|
|
|
|
target: target,
|
|
|
|
targetScheme: targetScheme,
|
2020-03-26 16:14:46 +03:00
|
|
|
project: project,
|
2018-10-18 16:29:45 +03:00
|
|
|
debugConfig: debugConfig.name,
|
|
|
|
releaseConfig: releaseConfig.name
|
|
|
|
)
|
2020-03-26 16:14:46 +03:00
|
|
|
let xcscheme = try generateScheme(scheme, for: target)
|
2018-10-18 16:29:45 +03:00
|
|
|
xcschemes.append(xcscheme)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return xcschemes
|
|
|
|
}
|
|
|
|
|
2020-03-26 16:14:46 +03:00
|
|
|
public func generateScheme(_ scheme: Scheme, for target: Target? = nil) throws -> XCScheme {
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2019-09-22 18:55:42 +03:00
|
|
|
func getBuildableReference(_ target: TargetReference) throws -> XCScheme.BuildableReference {
|
2019-09-14 11:59:15 +03:00
|
|
|
let pbxProj: PBXProj
|
2019-09-22 18:23:11 +03:00
|
|
|
let projectFilePath: String
|
2019-09-22 18:55:42 +03:00
|
|
|
switch target.location {
|
2019-09-22 18:23:11 +03:00
|
|
|
case .project(let project):
|
2019-10-15 09:08:30 +03:00
|
|
|
guard let projectReference = self.project.getProjectReference(project) else {
|
2019-10-24 02:21:32 +03:00
|
|
|
throw SchemeGenerationError.missingProject(project)
|
2019-09-22 18:23:11 +03:00
|
|
|
}
|
2019-10-27 03:23:35 +03:00
|
|
|
pbxProj = try getPBXProj(from: projectReference)
|
2019-10-15 09:08:30 +03:00
|
|
|
projectFilePath = projectReference.path
|
2019-09-22 18:23:11 +03:00
|
|
|
case .local:
|
2019-09-14 11:59:15 +03:00
|
|
|
pbxProj = self.pbxProj
|
2019-09-22 18:23:11 +03:00
|
|
|
projectFilePath = "\(self.project.name).xcodeproj"
|
2019-09-14 11:59:15 +03:00
|
|
|
}
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2019-09-22 18:55:42 +03:00
|
|
|
guard let pbxTarget = pbxProj.targets(named: target.name).first else {
|
2019-10-27 06:57:23 +03:00
|
|
|
throw SchemeGenerationError.missingTarget(target, projectPath: projectFilePath)
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
2019-10-15 09:47:28 +03:00
|
|
|
let buildableName: String
|
|
|
|
|
2019-10-27 06:57:23 +03:00
|
|
|
switch target.location {
|
2019-10-15 09:47:28 +03:00
|
|
|
case .project:
|
|
|
|
buildableName = pbxTarget.productNameWithExtension() ?? pbxTarget.name
|
|
|
|
case .local:
|
|
|
|
guard let _buildableName =
|
2019-10-27 14:37:41 +03:00
|
|
|
project.getTarget(target.name)?.filename ??
|
|
|
|
project.getAggregateTarget(target.name)?.name else {
|
2019-10-27 06:57:23 +03:00
|
|
|
fatalError("Unable to determinate \"buildableName\" for build target: \(target)")
|
2019-10-15 09:47:28 +03:00
|
|
|
}
|
|
|
|
buildableName = _buildableName
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
2019-09-15 18:36:52 +03:00
|
|
|
return XCScheme.BuildableReference(
|
2019-10-27 14:37:41 +03:00
|
|
|
referencedContainer: "container:\(projectFilePath)",
|
|
|
|
blueprint: pbxTarget,
|
|
|
|
buildableName: buildableName,
|
|
|
|
blueprintName: target.name
|
|
|
|
)
|
2019-09-15 18:36:52 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func getBuildEntry(_ buildTarget: Scheme.BuildTarget) throws -> XCScheme.BuildAction.Entry {
|
2019-09-22 18:55:42 +03:00
|
|
|
let buildableReference = try getBuildableReference(buildTarget.target)
|
2018-10-18 16:29:45 +03:00
|
|
|
return XCScheme.BuildAction.Entry(buildableReference: buildableReference, buildFor: buildTarget.buildTypes)
|
|
|
|
}
|
|
|
|
|
2018-11-03 11:04:28 +03:00
|
|
|
let testTargets = scheme.test?.targets ?? []
|
|
|
|
let testBuildTargets = testTargets.map {
|
2019-09-24 09:04:40 +03:00
|
|
|
Scheme.BuildTarget(target: $0.targetReference, buildTypes: BuildType.testOnly)
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
2019-09-14 11:59:15 +03:00
|
|
|
let testBuildTargetEntries = try testBuildTargets.map(getBuildEntry)
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2019-09-14 11:59:15 +03:00
|
|
|
let buildActionEntries: [XCScheme.BuildAction.Entry] = try scheme.build.targets.map(getBuildEntry)
|
2018-10-18 16:29:45 +03:00
|
|
|
|
|
|
|
func getExecutionAction(_ action: Scheme.ExecutionAction) -> XCScheme.ExecutionAction {
|
|
|
|
// ExecutionActions can require the use of build settings. Xcode allows the settings to come from a build or test target.
|
|
|
|
let environmentBuildable = action.settingsTarget.flatMap { settingsTarget in
|
2019-09-01 15:02:53 +03:00
|
|
|
(buildActionEntries + testBuildTargetEntries)
|
2018-10-18 16:29:45 +03:00
|
|
|
.first { settingsTarget == $0.buildableReference.blueprintName }?
|
|
|
|
.buildableReference
|
|
|
|
}
|
|
|
|
return XCScheme.ExecutionAction(scriptText: action.script, title: action.name, environmentBuildable: environmentBuildable)
|
|
|
|
}
|
|
|
|
|
2020-05-20 16:05:03 +03:00
|
|
|
let schemeTarget: Target?
|
|
|
|
|
2020-06-17 10:23:17 +03:00
|
|
|
if let targetName = scheme.run?.executable {
|
2020-05-20 16:05:03 +03:00
|
|
|
schemeTarget = project.getTarget(targetName)
|
|
|
|
} else {
|
|
|
|
schemeTarget = target ?? project.getTarget(scheme.build.targets.first!.target.name)
|
|
|
|
}
|
|
|
|
|
2020-04-23 16:00:44 +03:00
|
|
|
let shouldExecuteOnLaunch = schemeTarget?.shouldExecuteOnLaunch == true
|
2018-10-18 16:29:45 +03:00
|
|
|
|
2020-05-20 16:05:03 +03:00
|
|
|
let buildableReference = buildActionEntries.first(where: { $0.buildableReference.blueprintName == schemeTarget?.name })?.buildableReference ?? buildActionEntries.first!.buildableReference
|
2020-03-26 16:14:46 +03:00
|
|
|
let runnables = makeProductRunnables(for: schemeTarget, buildableReference: buildableReference)
|
2018-10-18 16:29:45 +03:00
|
|
|
|
|
|
|
let buildAction = XCScheme.BuildAction(
|
|
|
|
buildActionEntries: buildActionEntries,
|
|
|
|
preActions: scheme.build.preActions.map(getExecutionAction),
|
|
|
|
postActions: scheme.build.postActions.map(getExecutionAction),
|
|
|
|
parallelizeBuild: scheme.build.parallelizeBuild,
|
|
|
|
buildImplicitDependencies: scheme.build.buildImplicitDependencies
|
|
|
|
)
|
|
|
|
|
2018-11-03 11:04:28 +03:00
|
|
|
let testables = zip(testTargets, testBuildTargetEntries).map { testTarget, testBuilEntries in
|
2018-11-04 14:30:34 +03:00
|
|
|
XCScheme.TestableReference(
|
2020-08-05 13:05:23 +03:00
|
|
|
skipped: testTarget.skipped,
|
2018-11-04 14:30:34 +03:00
|
|
|
parallelizable: testTarget.parallelizable,
|
|
|
|
randomExecutionOrdering: testTarget.randomExecutionOrder,
|
2019-05-08 09:31:21 +03:00
|
|
|
buildableReference: testBuilEntries.buildableReference,
|
|
|
|
skippedTests: testTarget.skippedTests.map(XCScheme.SkippedTest.init)
|
2018-11-04 14:30:34 +03:00
|
|
|
)
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
2019-09-15 18:36:52 +03:00
|
|
|
let coverageBuildableTargets = try scheme.test?.coverageTargets.map {
|
2019-09-22 18:55:42 +03:00
|
|
|
try getBuildableReference($0)
|
2019-09-15 18:36:52 +03:00
|
|
|
} ?? []
|
|
|
|
|
2018-10-18 16:29:45 +03:00
|
|
|
let testCommandLineArgs = scheme.test.map { XCScheme.CommandLineArguments($0.commandLineArguments) }
|
|
|
|
let launchCommandLineArgs = scheme.run.map { XCScheme.CommandLineArguments($0.commandLineArguments) }
|
|
|
|
let profileCommandLineArgs = scheme.profile.map { XCScheme.CommandLineArguments($0.commandLineArguments) }
|
|
|
|
|
|
|
|
let testVariables = scheme.test.flatMap { $0.environmentVariables.isEmpty ? nil : $0.environmentVariables }
|
|
|
|
let launchVariables = scheme.run.flatMap { $0.environmentVariables.isEmpty ? nil : $0.environmentVariables }
|
|
|
|
let profileVariables = scheme.profile.flatMap { $0.environmentVariables.isEmpty ? nil : $0.environmentVariables }
|
|
|
|
|
|
|
|
let testAction = XCScheme.TestAction(
|
|
|
|
buildConfiguration: scheme.test?.config ?? defaultDebugConfig.name,
|
|
|
|
macroExpansion: buildableReference,
|
|
|
|
testables: testables,
|
|
|
|
preActions: scheme.test?.preActions.map(getExecutionAction) ?? [],
|
|
|
|
postActions: scheme.test?.postActions.map(getExecutionAction) ?? [],
|
2019-09-16 05:00:32 +03:00
|
|
|
selectedDebuggerIdentifier: (scheme.test?.debugEnabled ?? Scheme.Test.debugEnabledDefault) ? XCScheme.defaultDebugger : "",
|
2019-11-22 19:46:57 +03:00
|
|
|
selectedLauncherIdentifier: (scheme.test?.debugEnabled ?? Scheme.Test.debugEnabledDefault) ? XCScheme.defaultLauncher : "Xcode.IDEFoundation.Launcher.PosixSpawn",
|
2018-10-18 16:29:45 +03:00
|
|
|
shouldUseLaunchSchemeArgsEnv: scheme.test?.shouldUseLaunchSchemeArgsEnv ?? true,
|
2019-06-19 01:58:46 +03:00
|
|
|
codeCoverageEnabled: scheme.test?.gatherCoverageData ?? Scheme.Test.gatherCoverageDataDefault,
|
2019-09-15 18:36:52 +03:00
|
|
|
codeCoverageTargets: coverageBuildableTargets,
|
2019-10-30 09:17:08 +03:00
|
|
|
onlyGenerateCoverageForSpecifiedTargets: !coverageBuildableTargets.isEmpty,
|
2019-06-19 01:58:46 +03:00
|
|
|
disableMainThreadChecker: scheme.test?.disableMainThreadChecker ?? Scheme.Test.disableMainThreadCheckerDefault,
|
2018-10-18 16:29:45 +03:00
|
|
|
commandlineArguments: testCommandLineArgs,
|
2019-09-13 03:46:01 +03:00
|
|
|
environmentVariables: testVariables,
|
|
|
|
language: scheme.test?.language,
|
|
|
|
region: scheme.test?.region
|
2018-10-18 16:29:45 +03:00
|
|
|
)
|
|
|
|
|
2020-01-23 18:12:06 +03:00
|
|
|
let allowLocationSimulation = scheme.run?.simulateLocation?.allow ?? true
|
|
|
|
var locationScenarioReference: XCScheme.LocationScenarioReference?
|
|
|
|
if let simulateLocation = scheme.run?.simulateLocation, var identifier = simulateLocation.defaultLocation, let referenceType = simulateLocation.referenceType {
|
|
|
|
if referenceType == .gpx {
|
|
|
|
var path = Path("../\(identifier)")
|
|
|
|
path = path.simplifyingParentDirectoryReferences()
|
|
|
|
identifier = path.string
|
|
|
|
}
|
|
|
|
locationScenarioReference = XCScheme.LocationScenarioReference(identifier: identifier, referenceType: referenceType.rawValue)
|
|
|
|
}
|
2020-06-17 11:12:34 +03:00
|
|
|
|
2018-10-18 16:29:45 +03:00
|
|
|
let launchAction = XCScheme.LaunchAction(
|
2020-03-26 16:14:46 +03:00
|
|
|
runnable: shouldExecuteOnLaunch ? runnables.launch : nil,
|
2018-10-18 16:29:45 +03:00
|
|
|
buildConfiguration: scheme.run?.config ?? defaultDebugConfig.name,
|
|
|
|
preActions: scheme.run?.preActions.map(getExecutionAction) ?? [],
|
|
|
|
postActions: scheme.run?.postActions.map(getExecutionAction) ?? [],
|
|
|
|
macroExpansion: shouldExecuteOnLaunch ? nil : buildableReference,
|
2019-09-16 05:00:32 +03:00
|
|
|
selectedDebuggerIdentifier: (scheme.run?.debugEnabled ?? Scheme.Run.debugEnabledDefault) ? XCScheme.defaultDebugger : "",
|
2019-09-22 15:14:15 +03:00
|
|
|
selectedLauncherIdentifier: (scheme.run?.debugEnabled ?? Scheme.Run.debugEnabledDefault) ? XCScheme.defaultLauncher : "Xcode.IDEFoundation.Launcher.PosixSpawn",
|
2020-05-29 15:53:48 +03:00
|
|
|
askForAppToLaunch: scheme.run?.askForAppToLaunch,
|
2020-01-23 18:12:06 +03:00
|
|
|
allowLocationSimulation: allowLocationSimulation,
|
|
|
|
locationScenarioReference: locationScenarioReference,
|
2019-06-19 01:58:46 +03:00
|
|
|
disableMainThreadChecker: scheme.run?.disableMainThreadChecker ?? Scheme.Run.disableMainThreadCheckerDefault,
|
2020-03-04 19:21:18 +03:00
|
|
|
stopOnEveryMainThreadCheckerIssue: scheme.run?.stopOnEveryMainThreadCheckerIssue ?? Scheme.Run.stopOnEveryMainThreadCheckerIssueDefault,
|
2018-10-18 16:29:45 +03:00
|
|
|
commandlineArguments: launchCommandLineArgs,
|
2019-09-13 03:46:01 +03:00
|
|
|
environmentVariables: launchVariables,
|
|
|
|
language: scheme.run?.language,
|
2020-04-06 21:37:37 +03:00
|
|
|
region: scheme.run?.region,
|
|
|
|
launchAutomaticallySubstyle: scheme.run?.launchAutomaticallySubstyle
|
2018-10-18 16:29:45 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
let profileAction = XCScheme.ProfileAction(
|
2020-03-26 16:14:46 +03:00
|
|
|
buildableProductRunnable: runnables.profile,
|
2018-10-18 16:29:45 +03:00
|
|
|
buildConfiguration: scheme.profile?.config ?? defaultReleaseConfig.name,
|
|
|
|
preActions: scheme.profile?.preActions.map(getExecutionAction) ?? [],
|
|
|
|
postActions: scheme.profile?.postActions.map(getExecutionAction) ?? [],
|
|
|
|
shouldUseLaunchSchemeArgsEnv: scheme.profile?.shouldUseLaunchSchemeArgsEnv ?? true,
|
|
|
|
commandlineArguments: profileCommandLineArgs,
|
|
|
|
environmentVariables: profileVariables
|
|
|
|
)
|
|
|
|
|
|
|
|
let analyzeAction = XCScheme.AnalyzeAction(buildConfiguration: scheme.analyze?.config ?? defaultDebugConfig.name)
|
|
|
|
|
|
|
|
let archiveAction = XCScheme.ArchiveAction(
|
|
|
|
buildConfiguration: scheme.archive?.config ?? defaultReleaseConfig.name,
|
|
|
|
revealArchiveInOrganizer: scheme.archive?.revealArchiveInOrganizer ?? true,
|
|
|
|
customArchiveName: scheme.archive?.customArchiveName,
|
|
|
|
preActions: scheme.archive?.preActions.map(getExecutionAction) ?? [],
|
|
|
|
postActions: scheme.archive?.postActions.map(getExecutionAction) ?? []
|
|
|
|
)
|
|
|
|
|
|
|
|
return XCScheme(
|
|
|
|
name: scheme.name,
|
|
|
|
lastUpgradeVersion: project.xcodeVersion,
|
|
|
|
version: project.schemeVersion,
|
|
|
|
buildAction: buildAction,
|
|
|
|
testAction: testAction,
|
|
|
|
launchAction: launchAction,
|
|
|
|
profileAction: profileAction,
|
|
|
|
analyzeAction: analyzeAction,
|
2020-07-26 15:17:32 +03:00
|
|
|
archiveAction: archiveAction,
|
|
|
|
wasCreatedForAppExtension: schemeTarget
|
|
|
|
.flatMap { $0.type.isExtension ? true : nil }
|
2018-10-18 16:29:45 +03:00
|
|
|
)
|
|
|
|
}
|
2020-03-26 16:14:46 +03:00
|
|
|
|
|
|
|
private func makeProductRunnables(for target: Target?, buildableReference: XCScheme.BuildableReference) -> (launch: XCScheme.Runnable, profile: XCScheme.BuildableProductRunnable) {
|
|
|
|
let buildable = XCScheme.BuildableProductRunnable(buildableReference: buildableReference)
|
|
|
|
if target?.type.isWatchApp == true {
|
|
|
|
let remote = XCScheme.RemoteRunnable(
|
|
|
|
buildableReference: buildableReference,
|
|
|
|
bundleIdentifier: "com.apple.Carousel",
|
|
|
|
runnableDebuggingMode: "2"
|
|
|
|
)
|
|
|
|
return (remote, buildable)
|
|
|
|
} else {
|
|
|
|
return (buildable, buildable)
|
|
|
|
}
|
|
|
|
}
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|
|
|
|
|
2019-10-24 02:21:32 +03:00
|
|
|
enum SchemeGenerationError: Error, CustomStringConvertible {
|
|
|
|
|
2019-10-27 06:57:23 +03:00
|
|
|
case missingTarget(TargetReference, projectPath: String)
|
2019-10-24 02:21:32 +03:00
|
|
|
case missingProject(String)
|
|
|
|
|
|
|
|
var description: String {
|
|
|
|
switch self {
|
2019-10-27 06:57:23 +03:00
|
|
|
case .missingTarget(let target, let projectPath):
|
|
|
|
return "Unable to find target named \"\(target)\" in \"\(projectPath)\""
|
2019-10-24 02:21:32 +03:00
|
|
|
case .missingProject(let project):
|
|
|
|
return "Unable to find project reference named \"\(project)\" in project.yml"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-18 16:29:45 +03:00
|
|
|
extension Scheme {
|
2020-03-26 16:14:46 +03:00
|
|
|
public init(name: String, target: Target, targetScheme: TargetScheme, project: Project, debugConfig: String, releaseConfig: String) {
|
2018-10-18 16:29:45 +03:00
|
|
|
self.init(
|
|
|
|
name: name,
|
2020-03-20 20:23:50 +03:00
|
|
|
build: .init(
|
2020-03-26 16:14:46 +03:00
|
|
|
targets: Scheme.buildTargets(for: target, project: project),
|
2020-04-13 16:30:46 +03:00
|
|
|
buildImplicitDependencies: targetScheme.buildImplicitDependencies,
|
|
|
|
preActions: targetScheme.preActions,
|
|
|
|
postActions: targetScheme.postActions
|
2020-03-20 20:23:50 +03:00
|
|
|
),
|
2018-10-18 16:29:45 +03:00
|
|
|
run: .init(
|
|
|
|
config: debugConfig,
|
|
|
|
commandLineArguments: targetScheme.commandLineArguments,
|
2019-06-19 01:58:46 +03:00
|
|
|
environmentVariables: targetScheme.environmentVariables,
|
2019-11-25 22:37:10 +03:00
|
|
|
disableMainThreadChecker: targetScheme.disableMainThreadChecker,
|
2020-03-04 19:21:18 +03:00
|
|
|
stopOnEveryMainThreadCheckerIssue: targetScheme.stopOnEveryMainThreadCheckerIssue,
|
2019-11-25 22:37:10 +03:00
|
|
|
language: targetScheme.language,
|
|
|
|
region: targetScheme.region
|
2018-10-18 16:29:45 +03:00
|
|
|
),
|
|
|
|
test: .init(
|
|
|
|
config: debugConfig,
|
|
|
|
gatherCoverageData: targetScheme.gatherCoverageData,
|
2019-06-19 01:58:46 +03:00
|
|
|
disableMainThreadChecker: targetScheme.disableMainThreadChecker,
|
2018-10-18 16:29:45 +03:00
|
|
|
commandLineArguments: targetScheme.commandLineArguments,
|
|
|
|
targets: targetScheme.testTargets,
|
2019-11-25 22:37:10 +03:00
|
|
|
environmentVariables: targetScheme.environmentVariables,
|
|
|
|
language: targetScheme.language,
|
|
|
|
region: targetScheme.region
|
2018-10-18 16:29:45 +03:00
|
|
|
),
|
|
|
|
profile: .init(
|
|
|
|
config: releaseConfig,
|
|
|
|
commandLineArguments: targetScheme.commandLineArguments,
|
|
|
|
environmentVariables: targetScheme.environmentVariables
|
|
|
|
),
|
|
|
|
analyze: .init(
|
|
|
|
config: debugConfig
|
|
|
|
),
|
|
|
|
archive: .init(
|
2020-04-13 16:30:46 +03:00
|
|
|
config: releaseConfig
|
2018-10-18 16:29:45 +03:00
|
|
|
)
|
|
|
|
)
|
|
|
|
}
|
2020-03-26 16:14:46 +03:00
|
|
|
|
|
|
|
private static func buildTargets(for target: Target, project: Project) -> [BuildTarget] {
|
|
|
|
let buildTarget = Scheme.BuildTarget(target: TargetReference.local(target.name))
|
|
|
|
switch target.type {
|
|
|
|
case .watchApp, .watch2App:
|
|
|
|
let hostTarget = project.targets
|
|
|
|
.first { projectTarget in
|
|
|
|
projectTarget.dependencies.contains { $0.reference == target.name }
|
|
|
|
}
|
|
|
|
.map { BuildTarget(target: TargetReference.local($0.name)) }
|
|
|
|
return hostTarget.map { [buildTarget, $0] } ?? [buildTarget]
|
|
|
|
default:
|
|
|
|
return [buildTarget]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
extension PBXProductType {
|
|
|
|
var isWatchApp: Bool {
|
|
|
|
switch self {
|
|
|
|
case .watchApp, .watch2App:
|
|
|
|
return true
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
2018-10-18 16:29:45 +03:00
|
|
|
}
|