| // Copyright 2016 The Tulsi Authors. All rights reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| import Foundation |
| |
| |
| /// Provides functionality to generate an Xcode project from a TulsiGeneratorConfig. |
| final class XcodeProjectGenerator { |
| enum ProjectGeneratorError: Error { |
| /// General Xcode project creation failure with associated debug info. |
| case serializationFailed(String) |
| |
| /// The aspect info for the labels could not be built. |
| case labelAspectFailure(String) |
| |
| /// The given labels failed to resolve to valid targets. |
| case labelResolutionFailed(Set<BuildLabel>) |
| |
| /// The given |path| to generate this Xcode project is invalid because it is within |reason|. |
| case invalidXcodeProjectPath(path: String, reason: String) |
| } |
| |
| /// Encapsulates the source paths of various resources (scripts, etc...) that will be copied into |
| /// the generated Xcode project. |
| struct ResourceSourcePathURLs { |
| let buildScript: URL // The script to run on "build" actions. |
| let cleanScript: URL // The script to run on "clean" actions. |
| let extraBuildScripts: [URL] // Any additional scripts to install into the project bundle. |
| let iOSUIRunnerEntitlements: URL // Entitlements file template for iOS UI Test runner apps. |
| let macOSUIRunnerEntitlements: URL // Entitlements file template for macOS UI Test runner apps. |
| let stubInfoPlist: URL // Stub Info.plist (needed for Xcode 8). |
| let stubIOSAppExInfoPlistTemplate: URL // Stub Info.plist (needed for app extension targets). |
| let stubWatchOS2InfoPlist: URL // Stub Info.plist (needed for watchOS2 app targets). |
| let stubWatchOS2AppExInfoPlist: URL // Stub Info.plist (needed for watchOS2 appex targets). |
| |
| // In order to load tulsi_aspects, Tulsi constructs a Bazel repository inside of the generated |
| // Xcode project. Its structure looks like this: |
| // ├── Bazel |
| // │ ├── WORKSPACE |
| // │ └── tulsi |
| // │ ├── file1 |
| // │ └── ... |
| // These two items define the content of this repository, including the WORKSPACE file and the |
| // "tulsi" package. |
| let bazelWorkspaceFile: URL // Stub WORKSPACE file. |
| let tulsiPackageFiles: [URL] // Files to copy into the "tulsi" package. |
| } |
| |
| /// Path relative to PROJECT_FILE_PATH in which Tulsi generated files (scripts, artifacts, etc...) |
| /// should be placed. |
| private static let TulsiArtifactDirectory = ".tulsi" |
| static let ScriptDirectorySubpath = "\(TulsiArtifactDirectory)/Scripts" |
| static let BazelDirectorySubpath = "\(TulsiArtifactDirectory)/Bazel" |
| static let TulsiPackageName = "tulsi" |
| static let UtilDirectorySubpath = "\(TulsiArtifactDirectory)/Utils" |
| static let ConfigDirectorySubpath = "\(TulsiArtifactDirectory)/Configs" |
| static let ProjectResourcesDirectorySubpath = "\(TulsiArtifactDirectory)/Resources" |
| private static let BuildScript = "bazel_build.py" |
| private static let SettingsScript = "bazel_build_settings.py" |
| private static let CleanScript = "bazel_clean.sh" |
| private static let ShellCommandsUtil = "bazel_cache_reader" |
| private static let ShellCommandsCleanScript = "clean_symbol_cache" |
| private static let LLDBInitBootstrapScript = "bootstrap_lldbinit" |
| private static let WorkspaceFile = "WORKSPACE" |
| private static let IOSUIRunnerEntitlements = "iOSXCTRunner.entitlements" |
| private static let MacOSUIRunnerEntitlements = "macOSXCTRunner.entitlements" |
| private static let StubInfoPlistFilename = "StubInfoPlist.plist" |
| private static let StubWatchOS2InfoPlistFilename = "StubWatchOS2InfoPlist.plist" |
| private static let StubWatchOS2AppExInfoPlistFilename = "StubWatchOS2AppExInfoPlist.plist" |
| private static let CachedExecutionRootFilename = "execroot_path.py" |
| private static let DefaultSwiftVersion = "4" |
| private static let SupportScriptsPath = "Library/Application Support/Tulsi/Scripts" |
| |
| /// Rules which should not be generated at the top level. |
| private static let LibraryRulesForTopLevelWarning = |
| Set(["objc_library", "swift_library", "cc_library"]) |
| |
| private let workspaceRootURL: URL |
| private let config: TulsiGeneratorConfig |
| private let localizedMessageLogger: LocalizedMessageLogger |
| private let fileManager: FileManager |
| private let workspaceInfoExtractor: BazelWorkspaceInfoExtractorProtocol |
| private let resourceURLs: ResourceSourcePathURLs |
| private let tulsiVersion: String |
| |
| private let pbxTargetGeneratorType: PBXTargetGeneratorProtocol.Type |
| |
| /// Exposed for testing. Simply writes the given NSData to the given NSURL. |
| var writeDataHandler: (URL, Data) throws -> Void = { (outputFileURL: URL, data: Data) in |
| try data.write(to: outputFileURL, options: NSData.WritingOptions.atomic) |
| } |
| |
| /// Exposed for testing. Returns the current user name. |
| var usernameFetcher: () -> String = NSUserName |
| |
| /// Exposed for testing. Suppresses writing any preprocessor defines integral to Bazel itself into |
| /// the generated project. |
| var suppressCompilerDefines = false |
| |
| /// Exposed for testing. Instead of writing the real workspace name into the generated project, |
| /// write a stub value that will be the same regardless of the execution environment. |
| var redactWorkspaceSymlink = false |
| |
| /// Exposed for testing. Do not attempt to update/install files related to DBGShellCommands. |
| var suppressUpdatingShellCommands = false |
| |
| /// Exposed for testing. Do not modify user defaults. |
| var suppressModifyingUserDefaults = false |
| |
| /// Exposed for testing. Do not generate the build settings python file. |
| var suppressGeneratingBuildSettings = false |
| |
| var cachedDefaultSwiftVersion: String? |
| |
| init(workspaceRootURL: URL, |
| config: TulsiGeneratorConfig, |
| localizedMessageLogger: LocalizedMessageLogger, |
| workspaceInfoExtractor: BazelWorkspaceInfoExtractorProtocol, |
| resourceURLs: ResourceSourcePathURLs, |
| tulsiVersion: String, |
| fileManager: FileManager = FileManager.default, |
| pbxTargetGeneratorType: PBXTargetGeneratorProtocol.Type = PBXTargetGenerator.self) { |
| self.workspaceRootURL = workspaceRootURL |
| self.config = config |
| self.localizedMessageLogger = localizedMessageLogger |
| self.workspaceInfoExtractor = workspaceInfoExtractor |
| self.resourceURLs = resourceURLs |
| self.tulsiVersion = tulsiVersion |
| self.fileManager = fileManager |
| self.pbxTargetGeneratorType = pbxTargetGeneratorType |
| } |
| |
| /// Determines the "best" common SDKROOT for a sequence of RuleEntries. |
| static func projectSDKROOT<T>(_ targetRules: T) -> String? where T: Sequence, T.Iterator.Element == RuleEntry { |
| var discoveredSDKs = Set<String>() |
| for entry in targetRules { |
| if let sdkroot = entry.XcodeSDKRoot { |
| discoveredSDKs.insert(sdkroot) |
| } |
| } |
| |
| if discoveredSDKs.count == 1 { |
| return discoveredSDKs.first! |
| } |
| |
| if discoveredSDKs.isEmpty { |
| // In practice this should not happen since it'd indicate a project that won't be able to |
| // build. It is possible that the user is in the process of creating a new project, so |
| // rather than fail the generation a default is selected. Since iOS happens to be the best |
| // supported type by Bazel at the time of this writing, it is chosen as the default. |
| return "iphoneos" |
| } |
| |
| if discoveredSDKs == ["iphoneos", "watchos"] { |
| // Projects containing just an iPhone host and a watchOS app use iphoneos as the project SDK |
| // to match Xcode's behavior. |
| return "iphoneos" |
| } |
| |
| // Projects that have a collection that is not mappable to a standard Xcode project simply |
| // do not set the SDKROOT. Unfortunately this will cause "My Mac" to be listed as a target |
| // device regardless of whether or not the selected build target supports it, but this is |
| // a somewhat better user experience when compared to any other device SDK (in which Xcode |
| // will display every simulator for that platform regardless of whether or not the build |
| // target can be run on them). |
| return nil |
| } |
| |
| /// Generates an Xcode project bundle in the given folder. |
| /// NOTE: This may be a long running operation. |
| func generateXcodeProjectInFolder(_ outputFolderURL: URL) throws -> URL { |
| let generateProfilingToken = localizedMessageLogger.startProfiling("generating_project", |
| context: config.projectName) |
| defer { localizedMessageLogger.logProfilingEnd(generateProfilingToken) } |
| try validateXcodeProjectPath(outputFolderURL) |
| |
| let mainGroup = pbxTargetGeneratorType.mainGroupForOutputFolder(outputFolderURL, |
| workspaceRootURL: workspaceRootURL) |
| |
| let projectResourcesDirectory = "${PROJECT_FILE_PATH}/\(XcodeProjectGenerator.ProjectResourcesDirectorySubpath)" |
| let plistPaths = StubInfoPlistPaths( |
| resourcesDirectory: projectResourcesDirectory, |
| defaultStub: "\(projectResourcesDirectory)/\(XcodeProjectGenerator.StubInfoPlistFilename)", |
| watchOSStub: "\(projectResourcesDirectory)/\(XcodeProjectGenerator.StubWatchOS2InfoPlistFilename)", |
| watchOSAppExStub: "\(projectResourcesDirectory)/\(XcodeProjectGenerator.StubWatchOS2AppExInfoPlistFilename)") |
| |
| let projectInfo = try buildXcodeProjectWithMainGroup(mainGroup, |
| stubInfoPlistPaths: plistPaths) |
| |
| let serializingProgressNotifier = ProgressNotifier(name: SerializingXcodeProject, |
| maxValue: 1, |
| indeterminate: true) |
| let serializer = OpenStepSerializer(rootObject: projectInfo.project, |
| gidGenerator: ConcreteGIDGenerator()) |
| |
| let serializingProfileToken = localizedMessageLogger.startProfiling("serializing_project", |
| context: config.projectName) |
| guard let serializedXcodeProject = serializer.serialize() else { |
| throw ProjectGeneratorError.serializationFailed("OpenStep serialization failed") |
| } |
| localizedMessageLogger.logProfilingEnd(serializingProfileToken) |
| |
| let projectBundleName = config.xcodeProjectFilename |
| let projectURL = outputFolderURL.appendingPathComponent(projectBundleName) |
| if !createDirectory(projectURL) { |
| throw ProjectGeneratorError.serializationFailed("Project directory creation failed") |
| } |
| |
| let pbxproj = projectURL.appendingPathComponent("project.pbxproj") |
| try writeDataHandler(pbxproj, serializedXcodeProject) |
| serializingProgressNotifier.incrementValue() |
| |
| try installWorkspaceSettings(projectURL) |
| try installXcodeSchemesForProjectInfo(projectInfo, |
| projectURL: projectURL, |
| projectBundleName: projectBundleName) |
| installTulsiScriptsForProjectInfo(projectInfo, projectURL: projectURL) |
| installGeneratorConfig(projectURL) |
| installGeneratedProjectResources(projectURL) |
| installStubExtensionPlistFiles(projectURL, |
| rules: projectInfo.buildRuleEntries.filter { $0.pbxTargetType?.isiOSAppExtension ?? false }, |
| plistPaths: plistPaths) |
| linkTulsiWorkspace() |
| return projectURL |
| } |
| |
| // MARK: - Private methods |
| |
| /// Extracts the default swift version to use for targets without an explicit default by running |
| /// 'xcrun swift --version' if not already fetched. |
| private func fetchDefaultSwitchVersion() -> String { |
| // Used the already computed default version if it is available. |
| if let defaultSwiftVersion = cachedDefaultSwiftVersion { |
| return defaultSwiftVersion |
| } |
| |
| let semaphore = DispatchSemaphore(value: 0) |
| var completionInfo: ProcessRunner.CompletionInfo? |
| let process = TulsiProcessRunner.createProcess("/usr/bin/xcrun", |
| arguments: ["swift", "--version"], |
| messageLogger: self.localizedMessageLogger, |
| loggingIdentifier: "extract_default_swift_version") { |
| processCompletionInfo in |
| defer { semaphore.signal() } |
| |
| completionInfo = processCompletionInfo |
| } |
| process.launch() |
| _ = semaphore.wait(timeout: DispatchTime.distantFuture) |
| |
| guard let info = completionInfo else { |
| self.localizedMessageLogger.warning("ExtractingDefaultSwiftVersionFailed", |
| comment: "Default version in %1$@, additional error context in %2$@.", |
| values: XcodeProjectGenerator.DefaultSwiftVersion, |
| "Internal error, unable to find process information") |
| cachedDefaultSwiftVersion = XcodeProjectGenerator.DefaultSwiftVersion |
| return XcodeProjectGenerator.DefaultSwiftVersion |
| } |
| |
| guard info.terminationStatus == 0, |
| let stdout = NSString(data: info.stdout, encoding: String.Encoding.utf8.rawValue) else { |
| let stderr = NSString(data: info.stderr, encoding: String.Encoding.utf8.rawValue) ?? "<no stderr>" |
| self.localizedMessageLogger.warning("ExtractingDefaultSwiftVersionFailed", |
| comment: "Default version in %1$@, additional error context in %2$@.", |
| values: XcodeProjectGenerator.DefaultSwiftVersion, |
| "xcrun swift --version returned exitcode \(info.terminationStatus) with stderr: \(stderr)") |
| cachedDefaultSwiftVersion = XcodeProjectGenerator.DefaultSwiftVersion |
| return XcodeProjectGenerator.DefaultSwiftVersion |
| } |
| // Example output format: |
| // Apple Swift version 4.0.3 (swiftlang-900.0.74.1 clang-900.0.39.2) |
| // Target: x86_64-apple-macosx10.9 |
| // |
| // Note that we only care about the major and minor version number (e.g. 4.0, not 4.0.3). |
| let pattern = "^Apple\\sSwift\\sversion\\s([0-9]+\\.?[0-9]?)" |
| guard let regExpr = try? NSRegularExpression(pattern: pattern, options: .caseInsensitive) else { |
| self.localizedMessageLogger.warning("ExtractingDefaultSwiftVersionFailed", |
| comment: "Default version in %1$@, additional error context in %2$@.", |
| values: XcodeProjectGenerator.DefaultSwiftVersion, |
| "Internal error, unable to create regular expression") |
| cachedDefaultSwiftVersion = XcodeProjectGenerator.DefaultSwiftVersion |
| return XcodeProjectGenerator.DefaultSwiftVersion |
| } |
| guard let match = regExpr.firstMatch(in: stdout as String, |
| range: NSMakeRange(0, stdout.length)) else { |
| self.localizedMessageLogger.warning("ExtractingDefaultSwiftVersionFailed", |
| comment: "Default version in %1$@, additional error context in %2$@.", |
| values: XcodeProjectGenerator.DefaultSwiftVersion, |
| "Unable to parse version from xcrun output. Output: \(stdout)") |
| cachedDefaultSwiftVersion = XcodeProjectGenerator.DefaultSwiftVersion |
| return XcodeProjectGenerator.DefaultSwiftVersion |
| } |
| cachedDefaultSwiftVersion = stdout.substring(with: match.range(at: 1)) |
| return stdout.substring(with: match.range(at: 1)) |
| } |
| |
| /// Encapsulates information about the results of a buildXcodeProjectWithMainGroup invocation. |
| private struct GeneratedProjectInfo { |
| /// The newly created PBXProject instance. |
| let project: PBXProject |
| |
| /// RuleEntry's for which build targets were created. Note that this list may differ from the |
| /// set of targets selected by the user as part of the generator config. |
| let buildRuleEntries: Set<RuleEntry> |
| |
| /// RuleEntry's for test_suite's for which special test schemes should be created. |
| let testSuiteRuleEntries: [BuildLabel: RuleEntry] |
| |
| /// A mapping of indexer targets by name. |
| let indexerTargets: [String: PBXTarget] |
| } |
| |
| /// Throws an exception if the Xcode project path is found to be in a forbidden location, |
| /// assuming macOS default of a case-insensitive filesystem. |
| private func validateXcodeProjectPath(_ outputPath: URL) throws { |
| for (invalidPath, reason) in invalidXcodeProjectPathsWithReasons { |
| if outputPath.absoluteString.lowercased().range(of: invalidPath.lowercased()) != nil { |
| throw ProjectGeneratorError.invalidXcodeProjectPath(path: outputPath.path, reason: reason + |
| " (\"\(invalidPath)\")") |
| } |
| } |
| } |
| |
| /// Validates that the aspect output contains all targets listed in the config file and that |
| /// there are no ambiguous top-level targets. |
| private func validateConfigReferences(_ ruleEntryMap: RuleEntryMap) throws { |
| let unresolvedLabels = config.buildTargetLabels.filter { |
| !ruleEntryMap.hasAnyRuleEntry(withBuildLabel: $0) |
| } |
| if !unresolvedLabels.isEmpty { |
| throw ProjectGeneratorError.labelResolutionFailed(Set<BuildLabel>(unresolvedLabels)) |
| } |
| for label in config.buildTargetLabels { |
| if let entry = ruleEntryMap.anyRuleEntry(withBuildLabel: label), |
| XcodeProjectGenerator.LibraryRulesForTopLevelWarning.contains(entry.type) { |
| localizedMessageLogger.warning("TopLevelLibraryTarget", |
| comment: "Warning when a library target is used as a top level buildTarget. Target in %1$@, target type in %2$@.", |
| values: entry.label.description, entry.type) |
| } |
| } |
| } |
| |
| // Generates a PBXProject and a returns it along with a set of build, test and indexer targets. |
| private func buildXcodeProjectWithMainGroup(_ mainGroup: PBXGroup, |
| stubInfoPlistPaths: StubInfoPlistPaths) throws -> GeneratedProjectInfo { |
| let xcodeProject = PBXProject(name: config.projectName, mainGroup: mainGroup) |
| |
| if let enabled = config.options[.SuppressSwiftUpdateCheck].commonValueAsBool, enabled { |
| xcodeProject.lastSwiftUpdateCheck = "0710" |
| } |
| |
| let buildScriptPath = "${PROJECT_FILE_PATH}/\(XcodeProjectGenerator.ScriptDirectorySubpath)/\(XcodeProjectGenerator.BuildScript)" |
| let cleanScriptPath = "${PROJECT_FILE_PATH}/\(XcodeProjectGenerator.ScriptDirectorySubpath)/\(XcodeProjectGenerator.CleanScript)" |
| |
| let generator = pbxTargetGeneratorType.init(bazelPath: config.bazelURL.path, |
| bazelBinPath: workspaceInfoExtractor.bazelBinPath, |
| project: xcodeProject, |
| buildScriptPath: buildScriptPath, |
| stubInfoPlistPaths: stubInfoPlistPaths, |
| tulsiVersion: tulsiVersion, |
| options: config.options, |
| localizedMessageLogger: localizedMessageLogger, |
| workspaceRootURL: workspaceRootURL, |
| suppressCompilerDefines: suppressCompilerDefines, |
| redactWorkspaceSymlink: redactWorkspaceSymlink) |
| |
| if let additionalFilePaths = config.additionalFilePaths { |
| generator.generateFileReferencesForFilePaths(additionalFilePaths) |
| } |
| |
| let ruleEntryMap = try loadRuleEntryMap() |
| try validateConfigReferences(ruleEntryMap) |
| |
| var expandedTargetLabels = Set<BuildLabel>() |
| var testSuiteRules = [BuildLabel: RuleEntry]() |
| func expandTargetLabels<T: Sequence>(_ labels: T) where T.Iterator.Element == BuildLabel { |
| for label in labels { |
| // Effectively we will only be using the last RuleEntry in the case of duplicates. |
| // We could log about duplicates here, but this would only lead to duplicate logging. |
| let ruleEntries = ruleEntryMap.ruleEntries(buildLabel: label) |
| for ruleEntry in ruleEntries { |
| if ruleEntry.type != "test_suite" { |
| // Add the RuleEntry itself and any registered extensions. |
| expandedTargetLabels.insert(label) |
| expandedTargetLabels.formUnion(ruleEntry.extensions) |
| |
| // Recursively expand extensions. Currently used by App -> Watch App -> Watch Extension. |
| expandTargetLabels(ruleEntry.extensions) |
| } else { |
| // Expand the test_suite to its set of tests. |
| testSuiteRules[ruleEntry.label] = ruleEntry |
| expandTargetLabels(ruleEntry.testSuiteDependencies) |
| } |
| } |
| } |
| } |
| expandTargetLabels(config.buildTargetLabels) |
| |
| var targetRules = Set<RuleEntry>() |
| var hostTargetLabels = [BuildLabel: BuildLabel]() |
| |
| func profileAction(_ name: String, action: () throws -> Void) rethrows { |
| let profilingToken = localizedMessageLogger.startProfiling(name, context: config.projectName) |
| try action() |
| localizedMessageLogger.logProfilingEnd(profilingToken) |
| } |
| |
| profileAction("gathering_sources_for_indexers") { |
| // Map from RuleEntry to cumulative preprocessor framework search paths. |
| // This is used to propagate framework search paths up the graph while also making sure that |
| // each RuleEntry is only registered once. |
| var processedEntries = [RuleEntry: (NSOrderedSet)]() |
| let progressNotifier = ProgressNotifier(name: GatheringIndexerSources, |
| maxValue: expandedTargetLabels.count) |
| for label in expandedTargetLabels { |
| progressNotifier.incrementValue() |
| let ruleEntries = ruleEntryMap.ruleEntries(buildLabel: label) |
| guard !ruleEntries.isEmpty else { |
| localizedMessageLogger.error("UnknownTargetRule", |
| comment: "Failure to look up a Bazel target that was expected to be present. The target label is %1$@", |
| context: config.projectName, |
| values: label.value) |
| continue |
| } |
| for ruleEntry in ruleEntries { |
| targetRules.insert(ruleEntry) |
| for hostTargetLabel in ruleEntry.linkedTargetLabels { |
| hostTargetLabels[hostTargetLabel] = ruleEntry.label |
| } |
| autoreleasepool { |
| generator.registerRuleEntryForIndexer(ruleEntry, |
| ruleEntryMap: ruleEntryMap, |
| pathFilters: config.pathFilters, |
| processedEntries: &processedEntries) |
| } |
| } |
| } |
| } |
| var indexerTargets = [String: PBXTarget]() |
| profileAction("generating_indexers") { |
| let progressNotifier = ProgressNotifier(name: GeneratingIndexerTargets, |
| maxValue: 1, |
| indeterminate: true) |
| indexerTargets = generator.generateIndexerTargets() |
| progressNotifier.incrementValue() |
| } |
| |
| if let includeSkylarkSources = config.options[.IncludeBuildSources].commonValueAsBool, |
| includeSkylarkSources { |
| profileAction("adding_buildfiles") { |
| let buildfiles = workspaceInfoExtractor.extractBuildfiles(expandedTargetLabels) |
| let paths = buildfiles.map() { $0.asFileName! } |
| generator.generateFileReferencesForFilePaths(paths, pathFilters: config.pathFilters) |
| } |
| } |
| |
| // Add RuleEntrys for any test hosts to ensure that selected tests can be executed in Xcode. |
| for (hostLabel, _) in hostTargetLabels { |
| if config.buildTargetLabels.contains(hostLabel) { continue } |
| guard let recoveredHostRuleEntry = ruleEntryMap.anyRuleEntry(withBuildLabel: hostLabel) else { |
| // Already reported MissingTestHost warning in PBXTargetGenerator within |
| // generateBuildTargetsForRuleEntries(...). |
| continue |
| } |
| // Add the recovered test host target. |
| targetRules.insert(recoveredHostRuleEntry) |
| } |
| |
| let workingDirectory = pbxTargetGeneratorType.workingDirectoryForPBXGroup(mainGroup) |
| profileAction("generating_clean_target") { |
| generator.generateBazelCleanTarget(cleanScriptPath, workingDirectory: workingDirectory) |
| } |
| profileAction("generating_top_level_build_configs") { |
| var buildSettings = [String: String]() |
| if let sdkroot = XcodeProjectGenerator.projectSDKROOT(targetRules) { |
| buildSettings = ["SDKROOT": sdkroot] |
| } |
| // Pull in transitive settings from the top level targets. |
| for entry in targetRules { |
| if let swiftVersion = entry.attributes[.swift_language_version] as? String { |
| buildSettings["SWIFT_VERSION"] = swiftVersion |
| } else if entry.attributes[.has_swift_dependency] as? Bool ?? false { |
| buildSettings["SWIFT_VERSION"] = fetchDefaultSwitchVersion() |
| } |
| if let swiftToolchain = entry.attributes[.swift_toolchain] as? String { |
| buildSettings["TOOLCHAINS"] = swiftToolchain |
| } |
| } |
| |
| if let genRunfiles = config.options[.GenerateRunfiles].commonValueAsBool, genRunfiles { |
| buildSettings["GENERATE_RUNFILES"] = "YES" |
| } |
| |
| buildSettings["TULSI_PROJECT"] = config.projectName |
| generator.generateTopLevelBuildConfigurations(buildSettings) |
| } |
| try profileAction("generating_build_targets") { |
| try generator.generateBuildTargetsForRuleEntries(targetRules, |
| ruleEntryMap: ruleEntryMap) |
| } |
| |
| let referencePatcher = BazelXcodeProjectPatcher(fileManager: fileManager) |
| profileAction("patching_bazel_relative_references") { |
| referencePatcher.patchBazelRelativeReferences(xcodeProject, workspaceRootURL) |
| } |
| profileAction("patching_external_repository_references") { |
| referencePatcher.patchExternalRepositoryReferences(xcodeProject) |
| } |
| profileAction("updating_dbgshellcommands") { |
| do { |
| try updateShellCommands() |
| } catch { |
| self.localizedMessageLogger.warning("UpdatingDBGShellCommandsFailed", |
| comment: LocalizedMessageLogger.bugWorthyComment("Failed to update the script to find cached dSYM bundles via DBGShellCommands."), |
| context: self.config.projectName, |
| values: "\(error)") |
| } |
| } |
| profileAction("cleaning_cached_dsym_paths") { |
| cleanCachedDsymPaths() |
| } |
| profileAction("bootstrapping_lldbinit") { |
| bootstrapLLDBInit() |
| } |
| return GeneratedProjectInfo(project: xcodeProject, |
| buildRuleEntries: targetRules, |
| testSuiteRuleEntries: testSuiteRules, |
| indexerTargets: indexerTargets) |
| } |
| |
| private func installWorkspaceSettings(_ projectURL: URL) throws { |
| func writeWorkspaceSettings(_ workspaceSettings: [String: Any], |
| toDirectoryAtURL directoryURL: URL, |
| replaceIfExists: Bool = false) throws { |
| |
| let workspaceSettingsURL = directoryURL.appendingPathComponent("WorkspaceSettings.xcsettings") |
| if (!replaceIfExists && fileManager.fileExists(atPath: workspaceSettingsURL.path)) || |
| !createDirectory(directoryURL) { |
| return |
| } |
| |
| let data = try PropertyListSerialization.data(fromPropertyList: workspaceSettings, |
| format: .xml, |
| options: 0) |
| try writeDataHandler(workspaceSettingsURL, data) |
| } |
| |
| |
| let workspaceSharedDataURL = projectURL.appendingPathComponent("project.xcworkspace/xcshareddata") |
| let sharedWorkspaceSettings: [String: Any] = [ |
| "BuildSystemType": "Original", |
| "IDEWorkspaceSharedSettings_AutocreateContextsIfNeeded": false as AnyObject, |
| ] |
| try writeWorkspaceSettings(sharedWorkspaceSettings, |
| toDirectoryAtURL: workspaceSharedDataURL, |
| replaceIfExists: true) |
| |
| let workspaceUserDataURL = projectURL.appendingPathComponent("project.xcworkspace/xcuserdata/\(usernameFetcher()).xcuserdatad") |
| let perUserWorkspaceSettings: [String: Any] = [ |
| "LiveSourceIssuesEnabled": true, |
| "IssueFilterStyle": "ShowAll", |
| ] |
| try writeWorkspaceSettings(perUserWorkspaceSettings, toDirectoryAtURL: workspaceUserDataURL) |
| } |
| |
| private func loadRuleEntryMap() throws -> RuleEntryMap { |
| do { |
| let features = BazelBuildSettingsFeatures.enabledFeatures(options: config.options, |
| workspaceRoot: workspaceRootURL.path, |
| bazelExecRoot: workspaceInfoExtractor.bazelExecutionRoot) |
| return try workspaceInfoExtractor.ruleEntriesForLabels(config.buildTargetLabels, |
| startupOptions: config.options[.BazelBuildStartupOptionsDebug], |
| buildOptions: config.options[.BazelBuildOptionsDebug], |
| compilationModeOption: config.options[.ProjectGenerationCompilationMode], |
| platformConfigOption: config.options[.ProjectGenerationPlatformConfiguration], |
| prioritizeSwiftOption: config.options[.ProjectPrioritizesSwift], |
| features: features) |
| } catch BazelWorkspaceInfoExtractorError.aspectExtractorFailed(let info) { |
| throw ProjectGeneratorError.labelAspectFailure(info) |
| } |
| } |
| |
| // Links tulsi-workspace to the current Bazel execution root. This may be overwritten during |
| // builds, but is useful to include in project generation for users who have local_repository |
| // references. |
| private func linkTulsiWorkspace() { |
| // Don't create the tulsi-workspace symlink for tests. |
| guard !self.redactWorkspaceSymlink else { return } |
| |
| let path = workspaceRootURL.appendingPathComponent(PBXTargetGenerator.TulsiWorkspacePath, |
| isDirectory: false).path |
| let bazelExecRoot = self.workspaceInfoExtractor.bazelExecutionRoot; |
| |
| // See if tulsi-includes is already present. |
| if let attributes = try? fileManager.attributesOfItem(atPath: path) { |
| // If tulsi-includes is already a symlink, we only need to change it if it points to the wrong |
| // Bazel exec root. |
| if attributes[FileAttributeKey.type] as? FileAttributeType == FileAttributeType.typeSymbolicLink { |
| do { |
| let oldBazelExecRoot = try self.fileManager.destinationOfSymbolicLink(atPath: path) |
| guard oldBazelExecRoot != bazelExecRoot else { return } |
| } catch { |
| self.localizedMessageLogger.warning("UpdatingTulsiWorkspaceSymlinkFailed", |
| comment: "Warning shown when failing to update the tulsi-workspace symlink in %1$@ to the Bazel execution root, additional context %2$@.", |
| context: config.projectName, |
| values: path, "Unable to read old symlink. Was it modified?") |
| return |
| } |
| } |
| |
| // The symlink exists but points to the wrong path or is a different file type. Remove it. |
| do { |
| try fileManager.removeItem(atPath: path) |
| } catch { |
| self.localizedMessageLogger.warning("UpdatingTulsiWorkspaceSymlinkFailed", |
| comment: "Warning shown when failing to update the tulsi-workspace symlink in %1$@ to the Bazel execution root, additional context %2$@.", |
| context: config.projectName, |
| values: path, "Unable to remove the old tulsi-workspace symlink. Trying removing it and try again.") |
| return |
| } |
| } |
| |
| // Symlink tulsi-workspace -> Bazel exec root. |
| do { |
| try self.fileManager.createSymbolicLink(atPath: path, withDestinationPath: bazelExecRoot) |
| } catch { |
| self.localizedMessageLogger.warning("UpdatingTulsiWorkspaceSymlinkFailed", |
| comment: "Warning shown when failing to update the tulsi-workspace symlink in %1$@ to the Bazel execution root, additional context %2$@.", |
| context: config.projectName, |
| values: path, "Creating symlink failed. Is it already present?") |
| } |
| } |
| |
| // Writes Xcode schemes for non-indexer targets if they don't already exist. |
| private func installXcodeSchemesForProjectInfo(_ info: GeneratedProjectInfo, |
| projectURL: URL, |
| projectBundleName: String) throws { |
| let xcschemesURL = projectURL.appendingPathComponent("xcshareddata/xcschemes") |
| guard createDirectory(xcschemesURL) else { return } |
| |
| let userSchemeSubpath = "xcuserdata/\(usernameFetcher()).xcuserdatad/xcschemes" |
| let userSchemesURL = projectURL.appendingPathComponent(userSchemeSubpath) |
| guard createDirectory(userSchemesURL) else { return } |
| |
| func updateManagementDictionary( |
| _ dictionary: inout [String: Any], |
| schemeName: String, |
| shared: Bool = true, |
| visible: Bool = true |
| ) { |
| guard var schemeUserState = dictionary["SchemeUserState"] as? [String: Any] else { |
| return |
| } |
| let actualizedName = shared ? "\(schemeName)_^#shared#^_" : schemeName |
| let schemeDict: [String: Any] = ["isShown": visible] |
| schemeUserState[actualizedName] = schemeDict |
| dictionary["SchemeUserState"] = schemeUserState |
| } |
| |
| func targetForLabel(_ label: BuildLabel) -> PBXTarget? { |
| if let pbxTarget = info.project.targetByName[label.targetName!] { |
| return pbxTarget |
| } else if let pbxTarget = info.project.targetByName[label.asFullPBXTargetName!] { |
| return pbxTarget |
| } |
| return nil |
| } |
| |
| func commandlineArguments(for ruleEntry: RuleEntry) -> [String] { |
| return config.options[.CommandlineArguments, ruleEntry.label.value]?.components(separatedBy: " ") ?? [] |
| } |
| |
| func environmentVariables(for ruleEntry: RuleEntry) -> [String: String] { |
| var environmentVariables: [String: String] = [:] |
| config.options[.EnvironmentVariables, ruleEntry.label.value]?.components(separatedBy: .newlines).forEach() { keyValueString in |
| let components = keyValueString.components(separatedBy: "=") |
| let key = components.first ?? "" |
| if !key.isEmpty { |
| let value = components[1..<components.count].joined(separator: "=") |
| environmentVariables[key] = value |
| } |
| } |
| return environmentVariables |
| } |
| |
| func preActionScripts(for ruleEntry: RuleEntry) -> [XcodeActionType: String] { |
| var preActionScripts: [XcodeActionType: String] = [:] |
| preActionScripts[.BuildAction] = config.options[.BuildActionPreActionScript, ruleEntry.label.value] ?? nil |
| preActionScripts[.LaunchAction] = config.options[.LaunchActionPreActionScript, ruleEntry.label.value] ?? nil |
| preActionScripts[.TestAction] = config.options[.TestActionPreActionScript, ruleEntry.label.value] ?? nil |
| return preActionScripts |
| } |
| |
| func postActionScripts(for ruleEntry: RuleEntry) -> [XcodeActionType: String] { |
| var postActionScripts: [XcodeActionType: String] = [:] |
| postActionScripts[.BuildAction] = config.options[.BuildActionPostActionScript, ruleEntry.label.value] ?? nil |
| postActionScripts[.LaunchAction] = config.options[.LaunchActionPostActionScript, ruleEntry.label.value] ?? nil |
| postActionScripts[.TestAction] = config.options[.TestActionPostActionScript, ruleEntry.label.value] ?? nil |
| return postActionScripts |
| } |
| // Build a map of extension targets to hosts so the hosts may be referenced as additional build |
| // requirements. This is necessary for watchOS2 targets (Xcode will spawn an error when |
| // attempting to run the app without the scheme linkage, even though Bazel will create the |
| // embedded host correctly) and does not harm other extensions. |
| var extensionHosts = [BuildLabel: Set<RuleEntry>]() |
| for entry in info.buildRuleEntries { |
| for extensionLabel in entry.extensions { |
| if var entrySet = extensionHosts[extensionLabel] { |
| entrySet.insert(entry) |
| extensionHosts[extensionLabel] = entrySet |
| } else { |
| extensionHosts[extensionLabel] = Set([entry]) |
| } |
| } |
| } |
| |
| var schemeManagementDict = [String: Any]() |
| schemeManagementDict["SchemeUserState"] = [String: Any]() |
| schemeManagementDict["SuppressBuildableAutocreation"] = [String: Any]() |
| |
| let runTestTargetBuildConfigPrefix = pbxTargetGeneratorType.getRunTestTargetBuildConfigPrefix() |
| for entry in info.buildRuleEntries { |
| // Generate an XcodeScheme with a test action set up to allow tests to be run without Xcode |
| // attempting to compile code. |
| let target: PBXNativeTarget |
| if let pbxTarget = targetForLabel(entry.label) as? PBXNativeTarget { |
| target = pbxTarget |
| } else { |
| localizedMessageLogger.warning("XCSchemeGenerationFailed", |
| comment: "Warning shown when generation of an Xcode scheme failed for build target %1$@", |
| context: config.projectName, |
| values: entry.label.value) |
| continue |
| } |
| |
| let targetType = entry.pbxTargetType ?? .Application |
| |
| var appExtension: Bool = false |
| var extensionType: String? = nil |
| var launchStyle: XcodeScheme.LaunchStyle? = .Normal |
| var runnableDebuggingMode: XcodeScheme.RunnableDebuggingMode = .Default |
| |
| if targetType.isiOSAppExtension { |
| appExtension = true |
| launchStyle = .AppExtension |
| extensionType = entry.extensionType |
| } else if targetType.isWatchApp { |
| runnableDebuggingMode = .Remote |
| } else if targetType.isLibrary { |
| launchStyle = nil |
| } else if targetType.isTest { |
| // Test targets should be Buildable but not Runnable. |
| launchStyle = nil |
| } |
| |
| var schemeEnvVars = environmentVariables(for: entry) |
| if let genRunfiles = config.options[.GenerateRunfiles].commonValueAsBool, |
| let productType = entry.productType, |
| genRunfiles && (productType == .UnitTest || productType == .UIUnitTest) { |
| let bazelBinPath = "$(TULSI_WR)/\(workspaceInfoExtractor.bazelBinPath)" |
| schemeEnvVars["TEST_SRCDIR"] = "\(bazelBinPath)/$(TULSI_BUILD_PATH)/$(TARGET_NAME).runfiles" |
| } |
| |
| var extensionHostsForEntry = extensionHosts[entry.label] ?? Set<RuleEntry>() |
| // If the target is an extension with more than one host, add the host names as a prefix to |
| // the filename (eg. HOSTNAME_TARGETNAME.xcscheme). |
| let addHostNameToFilename = extensionHostsForEntry.count > 1 |
| |
| // Creates a new target for every extension-host pair. If the target is not an extension then |
| // a single target will be created. |
| repeat { |
| var filename = String() |
| var additionalBuildTargets = target.buildActionDependencies.map() { |
| ($0, projectBundleName, XcodeScheme.makeBuildActionEntryAttributes()) |
| } |
| |
| if !extensionHostsForEntry.isEmpty { |
| let host = extensionHostsForEntry.removeFirst() |
| guard let hostTarget = targetForLabel(host.label) else { |
| localizedMessageLogger.warning("XCSchemeGenerationFailed", |
| comment: "Warning shown when generation of an Xcode scheme failed for build target %1$@", |
| details: "Extension host could not be resolved.", |
| context: config.projectName, |
| values: entry.label.value) |
| continue |
| } |
| let hostTargetTuple = |
| (hostTarget, projectBundleName, XcodeScheme.makeBuildActionEntryAttributes()) |
| additionalBuildTargets.append(hostTargetTuple) |
| if addHostNameToFilename { |
| filename += hostTarget.name + "_" |
| } |
| } |
| |
| let scheme = XcodeScheme(target: target, |
| project: info.project, |
| projectBundleName: projectBundleName, |
| testActionBuildConfig: runTestTargetBuildConfigPrefix + "Debug", |
| profileActionBuildConfig: runTestTargetBuildConfigPrefix + "Release", |
| appExtension: appExtension, |
| extensionType: extensionType, |
| launchStyle: launchStyle, |
| runnableDebuggingMode: runnableDebuggingMode, |
| additionalBuildTargets: additionalBuildTargets, |
| commandlineArguments: commandlineArguments(for: entry), |
| environmentVariables: schemeEnvVars, |
| preActionScripts:preActionScripts(for: entry), |
| postActionScripts:postActionScripts(for: entry), |
| localizedMessageLogger: localizedMessageLogger) |
| let xmlDocument = scheme.toXML() |
| |
| filename += target.name + ".xcscheme" |
| let url = xcschemesURL.appendingPathComponent(filename) |
| |
| let data = xmlDocument.xmlData(options: XMLNode.Options.nodePrettyPrint) |
| try writeDataHandler(url, data) |
| updateManagementDictionary(&schemeManagementDict, schemeName: filename) |
| } while !extensionHostsForEntry.isEmpty |
| } |
| |
| func extractTestTargets(_ testSuite: RuleEntry) -> (Set<PBXTarget>, PBXTarget?) { |
| var suiteHostTarget: PBXTarget? = nil |
| var validTests = Set<PBXTarget>() |
| for testEntryLabel in testSuite.testSuiteDependencies { |
| if let recursiveTestSuite = info.testSuiteRuleEntries[testEntryLabel] { |
| let (recursiveTests, recursiveSuiteHostTarget) = extractTestTargets(recursiveTestSuite) |
| validTests.formUnion(recursiveTests) |
| if suiteHostTarget == nil { |
| suiteHostTarget = recursiveSuiteHostTarget |
| } |
| continue |
| } |
| |
| guard let testTarget = targetForLabel(testEntryLabel) as? PBXNativeTarget else { |
| localizedMessageLogger.warning("TestSuiteUsesUnresolvedTarget", |
| comment: "Warning shown when a test_suite %1$@ refers to a test label %2$@ that was not resolved and will be ignored", |
| context: config.projectName, |
| values: testSuite.label.value, testEntryLabel.value) |
| continue |
| } |
| |
| // Non XCTests are treated as standalone applications and cannot be included in an Xcode |
| // test scheme. |
| if testTarget.productType == .Application { |
| localizedMessageLogger.warning("TestSuiteIncludesNonXCTest", |
| comment: "Warning shown when a non XCTest %1$@ is included in a test suite %2$@ and will be ignored.", |
| context: config.projectName, |
| values: testEntryLabel.value, testSuite.label.value) |
| continue |
| } |
| |
| // Only UnitTests do not need a test host; they are considered 'logic tests'. |
| let testHostTarget = info.project.linkedHostForTestTarget(testTarget) as? PBXNativeTarget |
| if testHostTarget == nil && testTarget.productType != .UnitTest { |
| localizedMessageLogger.warning("TestSuiteTestHostResolutionFailed", |
| comment: "Warning shown when the test host for a test %1$@ inside test suite %2$@ could not be found. The test will be ignored, but this state is unexpected and should be reported.", |
| context: config.projectName, |
| values: testEntryLabel.value, testSuite.label.value) |
| continue |
| } |
| |
| if suiteHostTarget == nil { |
| suiteHostTarget = testHostTarget |
| } |
| |
| validTests.insert(testTarget) |
| } |
| |
| return (validTests, suiteHostTarget) |
| } |
| |
| func installSchemesForIndexerTargets() throws { |
| let indexerTargets = info.indexerTargets.values |
| guard !indexerTargets.isEmpty else { return } |
| |
| let filename = "_idx_Scheme.xcscheme" |
| let url = xcschemesURL.appendingPathComponent(filename) |
| |
| let additionalBuildTargets = indexerTargets.map() { |
| ($0, projectBundleName, XcodeScheme.makeBuildActionEntryAttributes()) |
| } |
| |
| let scheme = XcodeScheme(target: nil, |
| project: info.project, |
| projectBundleName: projectBundleName, |
| launchStyle: nil, |
| additionalBuildTargets: additionalBuildTargets, |
| preActionScripts: [:], |
| postActionScripts: [:], |
| localizedMessageLogger: localizedMessageLogger) |
| let xmlDocument = scheme.toXML() |
| |
| let data = xmlDocument.xmlData(options: XMLNode.Options.nodePrettyPrint) |
| try writeDataHandler(url, data) |
| updateManagementDictionary(&schemeManagementDict, schemeName: filename, visible: false) |
| } |
| try installSchemesForIndexerTargets() |
| |
| func installSchemeForTestSuite(_ suite: RuleEntry, named suiteName: String) throws { |
| let (validTests, extractedHostTarget) = extractTestTargets(suite) |
| guard !validTests.isEmpty else { |
| localizedMessageLogger.warning("TestSuiteHasNoValidTests", |
| comment: "Warning shown when none of the tests of a test suite %1$@ were able to be resolved.", |
| context: config.projectName, |
| values: suite.label.value) |
| return |
| } |
| |
| let filename = suiteName + "_Suite.xcscheme" |
| |
| let url = xcschemesURL.appendingPathComponent(filename) |
| let scheme = XcodeScheme(target: extractedHostTarget, |
| project: info.project, |
| projectBundleName: projectBundleName, |
| testActionBuildConfig: runTestTargetBuildConfigPrefix + "Debug", |
| profileActionBuildConfig: runTestTargetBuildConfigPrefix + "Release", |
| launchStyle: .Normal, |
| explicitTests: Array(validTests), |
| commandlineArguments: commandlineArguments(for: suite), |
| environmentVariables: environmentVariables(for: suite), |
| preActionScripts: preActionScripts(for: suite), |
| postActionScripts:postActionScripts(for: suite), |
| localizedMessageLogger: localizedMessageLogger) |
| let xmlDocument = scheme.toXML() |
| |
| |
| let data = xmlDocument.xmlData(options: XMLNode.Options.nodePrettyPrint) |
| try writeDataHandler(url, data) |
| updateManagementDictionary(&schemeManagementDict, schemeName: filename) |
| } |
| |
| var testSuiteSchemes = [String: [RuleEntry]]() |
| for (label, entry) in info.testSuiteRuleEntries { |
| let shortName = label.targetName! |
| if let _ = testSuiteSchemes[shortName] { |
| testSuiteSchemes[shortName]!.append(entry) |
| } else { |
| testSuiteSchemes[shortName] = [entry] |
| } |
| } |
| for testSuites in testSuiteSchemes.values { |
| for suite in testSuites { |
| let suiteName: String |
| if testSuites.count > 1 { |
| suiteName = suite.label.asFullPBXTargetName! |
| } else { |
| suiteName = suite.label.targetName! |
| } |
| try installSchemeForTestSuite(suite, named: suiteName) |
| } |
| } |
| |
| let schemeManagementURL = userSchemesURL.appendingPathComponent("xcschememanagement.plist") |
| guard savePlist(schemeManagementDict, url: schemeManagementURL) else { return } |
| } |
| |
| /// Create a file that contains Bazel build settings for the generated project. |
| private func generateBuildSettingsFile(_ buildRuleEntries: Set<RuleEntry>, |
| _ scriptDirectoryURL: URL) { |
| guard !suppressGeneratingBuildSettings else { return } |
| |
| let fileURL = scriptDirectoryURL.appendingPathComponent(XcodeProjectGenerator.SettingsScript) |
| |
| let bazelSettingsProvider = workspaceInfoExtractor.bazelSettingsProvider |
| let bazelExecRoot = workspaceInfoExtractor.bazelExecutionRoot |
| let features = BazelBuildSettingsFeatures.enabledFeatures(options: config.options, |
| workspaceRoot: workspaceRootURL.path, |
| bazelExecRoot: bazelExecRoot) |
| let bazelBuildSettings = bazelSettingsProvider.buildSettings(bazel: config.bazelURL.path, |
| bazelExecRoot: bazelExecRoot, |
| options: config.options, |
| features: features, |
| buildRuleEntries: buildRuleEntries) |
| |
| let bundle = Bundle(for: type(of: self)) |
| |
| guard let templateURL = bundle.url(forResource: XcodeProjectGenerator.SettingsScript, |
| withExtension: "template") else { |
| localizedMessageLogger.error("GeneratingBazelBuildSettingsFailed", |
| comment: "Error message for generating build settings failed. Internal error in %1$@.", |
| context: config.projectName, |
| values: "Resource not found: Unable to find the script to template.") |
| return |
| } |
| |
| guard let scriptTemplateData = fileManager.contents(atPath: templateURL.path) else { |
| localizedMessageLogger.error("GeneratingBazelBuildSettingsFailed", |
| comment: "Error message for generating build settings failed. Internal error in %1$@.", |
| context: config.projectName, |
| values: "Resource not readable: Unable to read the script to template.") |
| return |
| } |
| guard let scriptTemplate = String.init(data: scriptTemplateData, encoding: .utf8) else { |
| localizedMessageLogger.error("GeneratingBazelBuildSettingsFailed", |
| comment: "Error message for generating build settings failed. Internal error in %1$@.", |
| context: config.projectName, |
| values: "Resource parsing failed: Unable to load as utf8.") |
| return |
| } |
| let script = scriptTemplate.replacingOccurrences(of: "# <template>", |
| with: "# Generated by Tulsi. DO NOT EDIT.\nBUILD_SETTINGS = \(bazelBuildSettings.toPython(""))") |
| |
| var errorInfo: String? = nil |
| do { |
| try writeDataHandler(fileURL, script.data(using: .utf8)!) |
| } catch let e as NSError { |
| errorInfo = e.localizedDescription |
| } catch { |
| errorInfo = "Unexpected exception" |
| } |
| if let errorInfo = errorInfo { |
| localizedMessageLogger.error("GeneratingBazelBuildSettingsFailed", |
| comment: "Error message for generating build settings failed. Internal error in %1$@.", |
| context: config.projectName, |
| values: errorInfo) |
| return |
| } |
| } |
| |
| /// Copy the bazel_cache_reader to a subfolder in the user's Library, return the absolute path. |
| private func installShellCommands(atURL supportScriptsAbsoluteURL: URL) throws -> String { |
| |
| // Create all intermediate directories if they aren't present. |
| var isDir = ObjCBool(false) |
| if !fileManager.fileExists(atPath: supportScriptsAbsoluteURL.path, isDirectory: &isDir) { |
| try fileManager.createDirectory(atPath: supportScriptsAbsoluteURL.path, |
| withIntermediateDirectories: true, |
| attributes: nil) |
| } |
| |
| // Find bazel_cache_reader in Tulsi.app's Utilities folder. |
| let bundle = Bundle(for: type(of: self)) |
| let symbolCacheSourceURL = bundle.url(forResource: XcodeProjectGenerator.ShellCommandsUtil, |
| withExtension: "")! |
| |
| // Copy bazel_cache_reader to ~/Library/Application Support/Tulsi/Scripts |
| installFiles([(symbolCacheSourceURL, XcodeProjectGenerator.ShellCommandsUtil)], |
| toDirectory: supportScriptsAbsoluteURL) |
| |
| // Return the absolute path to ~/Library/Application Support/Tulsi/Scripts/bazel_cache_reader. |
| let shellCommandsURL = |
| supportScriptsAbsoluteURL.appendingPathComponent(XcodeProjectGenerator.ShellCommandsUtil, |
| isDirectory: false) |
| |
| return shellCommandsURL.path |
| } |
| |
| /// Update the global user defaults to reference bazel_cache_reader |
| private func updateGlobalUserDefaultsWithShellCommands(shellCommandsPath: String) { |
| guard !suppressModifyingUserDefaults else { return } |
| |
| // Check that bazel_cache_reader exists at the given path. If not, do nothing. |
| var isDir = ObjCBool(false) |
| guard fileManager.fileExists(atPath: shellCommandsPath, isDirectory: &isDir) else { |
| return |
| } |
| |
| // Find if there is an existing entry for com.apple.DebugSymbols. |
| let dbgDefaults = UserDefaults.standard.persistentDomain(forName: "com.apple.DebugSymbols") |
| |
| guard var currentDBGDefaults = dbgDefaults else { |
| // If no com.apple.DebugSymbols ever existed, create a new dictionary with our script for |
| // DBGShellCommands, and set DBGSpotlightPaths to an empty array to continue using Spotlight |
| // as a fallback for dSYM searches via LLDB and Instruments. |
| UserDefaults.standard.setPersistentDomain(["DBGShellCommands": [shellCommandsPath], |
| "DBGSpotlightPaths": []], |
| forName: "com.apple.DebugSymbols") |
| return |
| } |
| |
| // If there is one... |
| var newShellCommands : [String] = [] |
| |
| if let currentShellCommands = currentDBGDefaults["DBGShellCommands"] as? [String] { |
| // Check if shellCommandsPath is already in DBGShellCommands's array of Strings. |
| guard !currentShellCommands.contains(shellCommandsPath) else { |
| // Do nothing if it is. |
| return |
| } |
| // Copy all the current shell commands to the new DBGShellCommands array. |
| newShellCommands = currentShellCommands |
| |
| } else if let currentShellCommand = currentDBGDefaults["DBGShellCommands"] as? String { |
| // Check that the single path at DBGShellCommands is not the same as shellCommandsPath. |
| if currentShellCommand != shellCommandsPath { |
| // Add it to our new DBGShellCommands array in progress if it's not. |
| newShellCommands.append(currentShellCommand) |
| } |
| } |
| // Add shellCommandsPath to the new DBGShellCommands array. |
| newShellCommands.append(shellCommandsPath) |
| |
| // Replace DBGShellCommands in the existing com.apple.DebugSymbols defaults. |
| currentDBGDefaults["DBGShellCommands"] = newShellCommands |
| UserDefaults.standard.setPersistentDomain(currentDBGDefaults, forName: "com.apple.DebugSymbols") |
| } |
| |
| /// Install the latest bazel_cache_reader. |
| private func updateShellCommands() throws { |
| guard !suppressUpdatingShellCommands else { return } |
| |
| // Construct a URL to ~/Library/Application Support/Tulsi/Scripts. |
| let supportScriptsAbsoluteURL = fileManager.homeDirectoryForCurrentUser.appendingPathComponent( |
| XcodeProjectGenerator.SupportScriptsPath, isDirectory: true) |
| |
| // Install the latest version of the app to ~/Library/Application Support/Tulsi/Scripts/. |
| let shellCommandsAppPath = try installShellCommands(atURL: supportScriptsAbsoluteURL) |
| |
| // Add a reference to it in global user defaults. |
| updateGlobalUserDefaultsWithShellCommands(shellCommandsPath: shellCommandsAppPath) |
| } |
| |
| private func executePythonProcess(_ scriptFileName: String, onError: @escaping (Int32, String) -> Void) { |
| let bundle = Bundle(for: type(of: self)) |
| let cleanSymbolsSourceURL = bundle.url(forResource: scriptFileName, withExtension: "py")! |
| |
| let process = ProcessRunner.createProcess(cleanSymbolsSourceURL.path, |
| arguments: [String]()) { |
| completionInfo in |
| if completionInfo.terminationStatus != 0 { |
| if let stderr = NSString(data: completionInfo.stderr, |
| encoding: String.Encoding.utf8.rawValue) { |
| guard !stderr.trimmingCharacters(in: .whitespaces).isEmpty else { |
| return |
| } |
| onError(completionInfo.terminationStatus, stderr as String) |
| } |
| } |
| } |
| process.launch() |
| } |
| |
| private func cleanCachedDsymPaths() { |
| // Execute the script to clean up missing dSYM bundles asynchronously. |
| self.executePythonProcess(XcodeProjectGenerator.ShellCommandsCleanScript) { (returncode, stderr) in |
| self.localizedMessageLogger.warning("CleanCachedDsymsFailed", |
| comment: LocalizedMessageLogger.bugWorthyComment("Failed to clean cached references to existing dSYM bundles."), |
| context: self.config.projectName, |
| values: returncode, stderr) |
| } |
| } |
| |
| private func bootstrapLLDBInit() { |
| // Execute the script to bootstrap LLDBInit for path remapping. This needs to be read by Xcode |
| // before Xcode.app launches so that its instance of LLDB can find the file where we do the path |
| // remappings when dSYM bundles aren't present, which is ~/.lldbinit-tulsiproj. |
| self.executePythonProcess(XcodeProjectGenerator.LLDBInitBootstrapScript) { (returncode, stderr) in |
| self.localizedMessageLogger.warning("BootstrapLLDBInitFailed", |
| comment: LocalizedMessageLogger.bugWorthyComment("Failed to bootstrap LLDBInit for debug symbol remapping."), |
| context: self.config.projectName, |
| values: returncode, stderr) |
| } |
| } |
| |
| private func installTulsiScriptsForProjectInfo(_ projectInfo: GeneratedProjectInfo, |
| projectURL: URL) { |
| let scriptDirectoryURL = projectURL.appendingPathComponent(XcodeProjectGenerator.ScriptDirectorySubpath, |
| isDirectory: true) |
| if createDirectory(scriptDirectoryURL) { |
| let profilingToken = localizedMessageLogger.startProfiling("installing_scripts", |
| context: config.projectName) |
| let progressNotifier = ProgressNotifier(name: InstallingScripts, maxValue: 1) |
| defer { progressNotifier.incrementValue() } |
| localizedMessageLogger.infoMessage("Installing scripts") |
| installFiles([(resourceURLs.buildScript, XcodeProjectGenerator.BuildScript), |
| (resourceURLs.cleanScript, XcodeProjectGenerator.CleanScript), |
| ], |
| toDirectory: scriptDirectoryURL) |
| installFiles(resourceURLs.extraBuildScripts.map { ($0, $0.lastPathComponent) }, |
| toDirectory: scriptDirectoryURL) |
| generateBuildSettingsFile(projectInfo.buildRuleEntries, scriptDirectoryURL) |
| |
| localizedMessageLogger.logProfilingEnd(profilingToken) |
| } |
| } |
| |
| private func installGeneratorConfig(_ projectURL: URL) { |
| let configDirectoryURL = projectURL.appendingPathComponent(XcodeProjectGenerator.ConfigDirectorySubpath, |
| isDirectory: true) |
| guard createDirectory(configDirectoryURL, failSilently: true) else { return } |
| let profilingToken = localizedMessageLogger.startProfiling("installing_generator_config", |
| context: config.projectName) |
| let progressNotifier = ProgressNotifier(name: InstallingGeneratorConfig, maxValue: 1) |
| defer { progressNotifier.incrementValue() } |
| localizedMessageLogger.infoMessage("Installing generator config") |
| |
| let configURL = configDirectoryURL.appendingPathComponent(config.defaultFilename) |
| var errorInfo: String? = nil |
| do { |
| let data = try config.save() |
| try writeDataHandler(configURL, data as Data) |
| } catch let e as NSError { |
| errorInfo = e.localizedDescription |
| } catch { |
| errorInfo = "Unexpected exception" |
| } |
| if let errorInfo = errorInfo { |
| localizedMessageLogger.syslogMessage("Generator config serialization failed. \(errorInfo)", |
| context: config.projectName) |
| return |
| } |
| |
| let perUserConfigURL = configDirectoryURL.appendingPathComponent(TulsiGeneratorConfig.perUserFilename) |
| errorInfo = nil |
| do { |
| if let data = try config.savePerUserSettings() { |
| try writeDataHandler(perUserConfigURL, data as Data) |
| } |
| } catch let e as NSError { |
| errorInfo = e.localizedDescription |
| } catch { |
| errorInfo = "Unexpected exception" |
| } |
| if let errorInfo = errorInfo { |
| localizedMessageLogger.syslogMessage("Generator per-user config serialization failed. \(errorInfo)", |
| context: config.projectName) |
| return |
| } |
| localizedMessageLogger.logProfilingEnd(profilingToken) |
| } |
| |
| private func installGeneratedProjectResources(_ projectURL: URL) { |
| |
| let targetDirectoryURL = projectURL.appendingPathComponent(XcodeProjectGenerator.ProjectResourcesDirectorySubpath, |
| isDirectory: true) |
| guard createDirectory(targetDirectoryURL) else { return } |
| let profilingToken = localizedMessageLogger.startProfiling("installing_project_resources", |
| context: config.projectName) |
| localizedMessageLogger.infoMessage("Installing project resources") |
| |
| installFiles([(resourceURLs.iOSUIRunnerEntitlements, XcodeProjectGenerator.IOSUIRunnerEntitlements), |
| (resourceURLs.macOSUIRunnerEntitlements, XcodeProjectGenerator.MacOSUIRunnerEntitlements), |
| (resourceURLs.stubInfoPlist, XcodeProjectGenerator.StubInfoPlistFilename), |
| (resourceURLs.stubWatchOS2InfoPlist, XcodeProjectGenerator.StubWatchOS2InfoPlistFilename), |
| (resourceURLs.stubWatchOS2AppExInfoPlist, XcodeProjectGenerator.StubWatchOS2AppExInfoPlistFilename), |
| ], |
| toDirectory: targetDirectoryURL) |
| |
| |
| localizedMessageLogger.logProfilingEnd(profilingToken) |
| } |
| |
| private func installStubExtensionPlistFiles(_ projectURL: URL, rules: [RuleEntry], plistPaths: StubInfoPlistPaths) { |
| let targetDirectoryURL = projectURL.appendingPathComponent(XcodeProjectGenerator.ProjectResourcesDirectorySubpath, |
| isDirectory: true) |
| guard createDirectory(targetDirectoryURL) else { return } |
| let profilingToken = localizedMessageLogger.startProfiling("installing_plist_files", |
| context: config.projectName) |
| localizedMessageLogger.infoMessage("Installing plist files") |
| |
| let templatePath = resourceURLs.stubIOSAppExInfoPlistTemplate.path |
| guard let plistTemplateData = fileManager.contents(atPath: templatePath) else { |
| localizedMessageLogger.error("PlistTemplateNotFound", |
| comment: LocalizedMessageLogger.bugWorthyComment("Failed to load a plist template"), |
| context: config.projectName, |
| values: templatePath) |
| return |
| } |
| |
| let plistTemplate: NSDictionary |
| do { |
| plistTemplate = try PropertyListSerialization.propertyList(from: plistTemplateData, |
| options: PropertyListSerialization.ReadOptions.mutableContainers, |
| format: nil) as! NSDictionary |
| } catch let e { |
| localizedMessageLogger.error("PlistDeserializationFailed", |
| comment: LocalizedMessageLogger.bugWorthyComment("Failed to deserialize a plist template"), |
| context: config.projectName, |
| values: resourceURLs.stubIOSAppExInfoPlistTemplate.path, e.localizedDescription) |
| return |
| } |
| |
| for entry in rules { |
| plistTemplate.setValue(entry.extensionType, forKeyPath: "NSExtension.NSExtensionPointIdentifier") |
| |
| let plistName = plistPaths.plistFilename(forRuleEntry: entry) |
| let targetURL = URL(string: plistName, relativeTo: targetDirectoryURL)! |
| |
| guard savePlist(plistTemplate, url: targetURL) else { |
| return |
| } |
| } |
| |
| |
| localizedMessageLogger.logProfilingEnd(profilingToken) |
| } |
| |
| private func savePlist(_ plist: Any, url: URL) -> Bool { |
| let data: Data |
| do { |
| data = try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0) |
| } catch let e { |
| let comment = LocalizedMessageLogger.bugWorthyComment("Failed to serialize a plist") |
| localizedMessageLogger.error("SerializingPlistFailed", |
| comment: comment, |
| context: config.projectName, |
| values: e.localizedDescription) |
| return false |
| } |
| |
| guard fileManager.createFile(atPath: url.path, contents: data, attributes: nil) else { |
| let comment = LocalizedMessageLogger.bugWorthyComment("Failed to write a plist") |
| localizedMessageLogger.error("WritingPlistFailed", |
| comment: comment, |
| context: config.projectName, |
| values: url.path) |
| return false |
| } |
| return true |
| } |
| |
| private func createDirectory(_ resourceDirectoryURL: URL, failSilently: Bool = false) -> Bool { |
| do { |
| try fileManager.createDirectory(at: resourceDirectoryURL, |
| withIntermediateDirectories: true, |
| attributes: nil) |
| } catch let e as NSError { |
| if !failSilently { |
| localizedMessageLogger.error("DirectoryCreationFailed", |
| comment: "Failed to create an important directory. The resulting project will most likely be broken. A bug should be reported.", |
| context: config.projectName, |
| values: resourceDirectoryURL as NSURL, e.localizedDescription) |
| } |
| return false |
| } |
| return true |
| } |
| |
| private func installFiles(_ files: [(sourceURL: URL, filename: String)], |
| toDirectory directory: URL, failSilently: Bool = false) { |
| for (sourceURL, filename) in files { |
| let targetURL = directory.appendingPathComponent(filename, isDirectory: false) |
| |
| let errorInfo: String? |
| do { |
| // Only over-write if needed. |
| if fileManager.fileExists(atPath: targetURL.path) { |
| guard !fileManager.contentsEqual(atPath: sourceURL.path, andPath: targetURL.path) else { |
| continue; |
| } |
| print("Overwriting \(targetURL.path) as its contents changed.") |
| try fileManager.removeItem(at: targetURL) |
| } |
| try fileManager.copyItem(at: sourceURL, to: targetURL) |
| errorInfo = nil |
| } catch let e as NSError { |
| errorInfo = e.localizedDescription |
| } catch { |
| errorInfo = "Unexpected exception" |
| } |
| if !failSilently, let errorInfo = errorInfo { |
| let targetURLString = targetURL.absoluteString |
| localizedMessageLogger.error("CopyingResourceFailed", |
| comment: "Failed to copy an important file resource, the resulting project will most likely be broken. A bug should be reported.", |
| context: config.projectName, |
| values: sourceURL as NSURL, targetURLString, errorInfo) |
| } |
| } |
| } |
| |
| |
| func logPendingMessages() { |
| if workspaceInfoExtractor.hasQueuedInfoMessages() { |
| localizedMessageLogger.debugMessage("Printing Bazel logs that could contain the error.") |
| workspaceInfoExtractor.logQueuedInfoMessages() |
| } |
| } |
| |
| |
| /// Models a node in a path trie. |
| private class PathTrie { |
| private var root = PathNode(pathElement: "") |
| |
| func insert(_ path: URL) { |
| let components = path.pathComponents |
| guard !components.isEmpty else { |
| return |
| } |
| root.addPath(components) |
| } |
| |
| func leafPaths() -> [URL] { |
| var ret = [URL]() |
| for n in root.children.values { |
| for path in n.leafPaths() { |
| guard let url = NSURL.fileURL(withPathComponents: path) else { |
| continue |
| } |
| ret.append(url as URL) |
| } |
| } |
| return ret |
| } |
| |
| private class PathNode { |
| let value: String |
| var children = [String: PathNode]() |
| |
| init(pathElement: String) { |
| self.value = pathElement |
| } |
| |
| func addPath<T: Collection>(_ pathComponents: T) |
| where T.SubSequence : Collection, |
| T.Iterator.Element == String { |
| guard let firstComponent = pathComponents.first else { |
| return |
| } |
| |
| let node: PathNode |
| if let existingNode = children[firstComponent] { |
| node = existingNode |
| } else { |
| node = PathNode(pathElement: firstComponent) |
| children[firstComponent] = node |
| } |
| let remaining = pathComponents.dropFirst() |
| if !remaining.isEmpty { |
| node.addPath(remaining) |
| } |
| } |
| |
| func leafPaths() -> [[String]] { |
| if children.isEmpty { |
| return [[value]] |
| } |
| var ret = [[String]]() |
| for n in children.values { |
| for childPath in n.leafPaths() { |
| var subpath = [value] |
| subpath.append(contentsOf: childPath) |
| ret.append(subpath) |
| } |
| } |
| return ret |
| } |
| } |
| } |
| } |
