src/Tulsi/HeadlessXcodeProjectGenerator.swift - tulsi - Git at Google

 // 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 Cocoa
 import TulsiGenerator


 /// Provides functionality to generate an Xcode project from a TulsiGeneratorConfig
 struct HeadlessXcodeProjectGenerator {
   let arguments: TulsiCommandlineParser.Arguments

   /// Performs project generation.
   func generate() throws {
     TulsiProjectDocument.showAlertsOnErrors = false

     let explicitBazelURL: URL?
     if let bazelPath = arguments.bazel {
       if !FileManager.default.isExecutableFile(atPath: bazelPath) {
         throw HeadlessModeError.invalidBazelPath
       }
       explicitBazelURL = URL(fileURLWithPath: bazelPath)
       TulsiProjectDocument.suppressRuleEntryUpdateOnLoad = true
     } else {
       explicitBazelURL = nil
     }

     defer {
       TulsiProjectDocument.showAlertsOnErrors = true
       TulsiProjectDocument.suppressRuleEntryUpdateOnLoad = false
     }

     guard let configPath = arguments.generatorConfig else {
       fatalError("HeadlessXcodeProjectGenerator invoked without a valid generatorConfig")
     }

     let (projectURL, configURL, defaultOutputFolderURL) = try resolveConfigPath(configPath)

     let documentController = NSDocumentController.shared
     let doc: NSDocument
     do {
       doc = try documentController.makeDocument(withContentsOf: projectURL,
                                                                  ofType: "com.google.tulsi.project")
     } catch TulsiProjectDocument.DocumentError.invalidWorkspace(let info) {
       throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to invalid workspace: \(info)")
     } catch let e as NSError {
       throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to unexpected exception: \(e)")
     } catch {
       throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to unexpected exception.")
     }
     guard let projectDocument = doc as? TulsiProjectDocument else {
       throw HeadlessModeError.invalidProjectFileContents("\(doc) is not of the expected type.")
     }

     let outputFolderURL: URL
     if let option = arguments.outputFolder {
       outputFolderURL = URL(fileURLWithPath: option, isDirectory: true)
     } else if let defaultOutputFolderURL = defaultOutputFolderURL {
       outputFolderURL = defaultOutputFolderURL
     } else {
       throw HeadlessModeError.explicitOutputOptionRequired
     }

     var config = try loadConfig(configURL, bazelURL: explicitBazelURL)
     config = config.configByAppendingPathFilters(arguments.additionalPathFilters)
     if let project = projectDocument.project {
       config = config.configByResolvingInheritedSettingsFromProject(project)
     }
     if let extraFlags = arguments.buildOptions {
       config.options[.BazelBuildOptionsDebug].appendProjectValue(extraFlags)
       config.options[.BazelBuildOptionsRelease].appendProjectValue(extraFlags)
     }

     let workspaceRootURL: URL
     let projectWorkspaceRootURL = projectDocument.workspaceRootURL
     if let workspaceRootOverride = arguments.workspaceRootOverride {
       workspaceRootURL = URL(fileURLWithPath: workspaceRootOverride, isDirectory: true)
       if !isExistingDirectory(workspaceRootURL) {
         throw HeadlessModeError.invalidWorkspaceRootOverride
       }
       if projectWorkspaceRootURL != nil {
         print("Overriding project workspace root (\(projectWorkspaceRootURL!.path)) with " +
             "command-line parameter (\(workspaceRootOverride))")
       }
     } else {
       guard let projectWorkspaceRootURL = projectWorkspaceRootURL else {
         throw HeadlessModeError.invalidProjectFileContents("Invalid workspaceRoot")
       }
       workspaceRootURL = projectWorkspaceRootURL as URL
     }

     if let announcementIdToMarkRead = arguments.announcementId {
       guard
         let announcement = try Announcement.loadAnnouncement(byId: announcementIdToMarkRead)
       else {
         throw HeadlessModeError.invalidAnnouncementId
       }

       announcement.recordDismissal()
       print("\(announcementIdToMarkRead) has been marked read and will not appear again.")
     }

     let announcement = try? Announcement.getNextUnreadAnnouncement()

     if let announcementToDisplay = announcement, announcementToDisplay.shouldAppearAtTopOfCLIOutput
     {
       print(announcementToDisplay.createCLIOutput())
     }

     print("Generating project into '\(outputFolderURL.path)' using:\n" +
               "\tconfig at '\(configURL.path)'\n" +
               "\tBazel workspace at '\(workspaceRootURL.path)'\n" +
               "\tBazel at '\(config.bazelURL.path)'.\n" +
               "This may take a while.")

     let result = TulsiGeneratorConfigDocument.generateXcodeProjectInFolder(outputFolderURL,
                                                                            withGeneratorConfig: config,
                                                                            workspaceRootURL: workspaceRootURL,
                                                                            messageLog: nil)

     switch result {
       case .success(let url):
         print("Generated project at \(url.path)")
         if arguments.openXcodeOnSuccess {
           print("Opening generated project in Xcode")
           NSWorkspace.shared.open(url)
         }
       case .failure:
         throw HeadlessModeError.generationFailed
     }

     if let announcementToDisplay = announcement,
       !announcementToDisplay.shouldAppearAtTopOfCLIOutput
     {
       print(announcementToDisplay.createCLIOutput())
     }
   }

   // MARK: - Private methods

   private func resolveConfigPath(_ path: String) throws -> (projectURL: URL,
                                                           configURL: URL,
                                                           defaultOutputFolderURL: URL?) {
     let tulsiProjExtension = TulsiProjectDocument.getTulsiBundleExtension()
     let components = path.components(separatedBy: ":")
     if components.count == 2 {
       var pathString = components[0] as NSString
       let projectExtension = pathString.pathExtension
       if projectExtension != tulsiProjExtension {
         pathString = pathString.appendingPathExtension(tulsiProjExtension)! as NSString
       }
       let projectURL = URL(fileURLWithPath: pathString as String)
       let (configURL, defaultOutputFolderURL) = try locateConfigNamed(components[1],
                                                                       inTulsiProject: pathString as String)
       return (projectURL, configURL, defaultOutputFolderURL)
     }

     var pathString = path as NSString
     let pathExtension = pathString.pathExtension
     var isProject = pathExtension == tulsiProjExtension
     if !isProject && pathExtension.isEmpty {
       // See if the user provided a Tulsiproj bundle without the extension or if there is a
       // tulsiproj bundle with the same name as the given directory.
       let projectPath = pathString.appendingPathExtension(tulsiProjExtension)!
       if isExistingDirectory(URL(fileURLWithPath: projectPath, isDirectory: true)) {
         isProject = true
         pathString = projectPath as NSString
       } else {
         let projectName = (pathString.lastPathComponent as NSString).appendingPathExtension(tulsiProjExtension)!
         let projectWithinPath = pathString.appendingPathComponent(projectName)
         if isExistingDirectory(URL(fileURLWithPath: projectWithinPath, isDirectory: true)) {
           isProject = true
           pathString = projectWithinPath as NSString
         }
       }
     }
     if isProject {
       let project = pathString.lastPathComponent as NSString
       let projectName = project.deletingPathExtension
       let (configURL, defaultOutputFolderURL) = try locateConfigNamed(projectName,
                                                                       inTulsiProject: pathString as String)
       let projectURL = URL(fileURLWithPath: pathString as String)
       return (projectURL, configURL, defaultOutputFolderURL)
     }

     throw HeadlessModeError.invalidConfigPath("The given config is invalid")
   }

   private func locateConfigNamed(_ configName: String,
                                  inTulsiProject tulsiProj: String) throws -> (configURL: URL, defaultOutputFolderURL: URL?) {
     let tulsiProjectURL = URL(fileURLWithPath: tulsiProj, isDirectory: true)
     if !isExistingDirectory(tulsiProjectURL) {
       throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not exist")
     }

     let configDirectoryURL = tulsiProjectURL.appendingPathComponent(TulsiProjectDocument.ProjectConfigsSubpath)
     if !isExistingDirectory(configDirectoryURL) {
       throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not contain any configs")
     }

     let configFilename: String
     if configName.hasSuffix(TulsiGeneratorConfig.FileExtension) {
       configFilename = configName
     } else {
       configFilename = "\(configName).\(TulsiGeneratorConfig.FileExtension)"
     }

     let configFileURL = configDirectoryURL.appendingPathComponent(configFilename)
     if FileManager.default.isReadableFile(atPath: configFileURL.path) {
       return (configFileURL, tulsiProjectURL.deletingLastPathComponent())
     }
     throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not contain a Tulsi config named \(configName).")
   }

   private func isExistingDirectory(_ url: URL) -> Bool {
     var isDirectory = ObjCBool(false)
     if !FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory) {
       return false
     }
     return isDirectory.boolValue
   }

   private func loadConfig(_ url: URL, bazelURL: URL?) throws -> TulsiGeneratorConfig {
     let config: TulsiGeneratorConfig
     do {
       config = try TulsiGeneratorConfig.load(url, bazelURL: bazelURL)
     } catch TulsiGeneratorConfig.ConfigError.badInputFilePath {
       throw HeadlessModeError.invalidConfigFileContents("Failed to read config file at \(url.path)")
     } catch TulsiGeneratorConfig.ConfigError.failedToReadAdditionalOptionsData(let info) {
       throw HeadlessModeError.invalidConfigFileContents("Failed to read per-user config file: \(info)")
     } catch TulsiGeneratorConfig.ConfigError.deserializationFailed(let info) {
       throw HeadlessModeError.invalidConfigFileContents("Config file at \(url.path) is invalid: \(info)")
     } catch {
       throw HeadlessModeError.invalidConfigFileContents("Unexpected exception reading config file at \(url.path)")
     }

     if !config.bazelURL.isFileURL {
       throw HeadlessModeError.invalidBazelPath
     }
     return config
   }
 }
	// 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 Cocoa
	import TulsiGenerator


	/// Provides functionality to generate an Xcode project from a TulsiGeneratorConfig
	struct HeadlessXcodeProjectGenerator {
	let arguments: TulsiCommandlineParser.Arguments

	/// Performs project generation.
	func generate() throws {
	TulsiProjectDocument.showAlertsOnErrors = false

	let explicitBazelURL: URL?
	if let bazelPath = arguments.bazel {
	if !FileManager.default.isExecutableFile(atPath: bazelPath) {
	throw HeadlessModeError.invalidBazelPath
	}
	explicitBazelURL = URL(fileURLWithPath: bazelPath)
	TulsiProjectDocument.suppressRuleEntryUpdateOnLoad = true
	} else {
	explicitBazelURL = nil
	}

	defer {
	TulsiProjectDocument.showAlertsOnErrors = true
	TulsiProjectDocument.suppressRuleEntryUpdateOnLoad = false
	}

	guard let configPath = arguments.generatorConfig else {
	fatalError("HeadlessXcodeProjectGenerator invoked without a valid generatorConfig")
	}

	let (projectURL, configURL, defaultOutputFolderURL) = try resolveConfigPath(configPath)

	let documentController = NSDocumentController.shared
	let doc: NSDocument
	do {
	doc = try documentController.makeDocument(withContentsOf: projectURL,
	ofType: "com.google.tulsi.project")
	} catch TulsiProjectDocument.DocumentError.invalidWorkspace(let info) {
	throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to invalid workspace: \(info)")
	} catch let e as NSError {
	throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to unexpected exception: \(e)")
	} catch {
	throw HeadlessModeError.invalidProjectFileContents("Failed to load project due to unexpected exception.")
	}
	guard let projectDocument = doc as? TulsiProjectDocument else {
	throw HeadlessModeError.invalidProjectFileContents("\(doc) is not of the expected type.")
	}

	let outputFolderURL: URL
	if let option = arguments.outputFolder {
	outputFolderURL = URL(fileURLWithPath: option, isDirectory: true)
	} else if let defaultOutputFolderURL = defaultOutputFolderURL {
	outputFolderURL = defaultOutputFolderURL
	} else {
	throw HeadlessModeError.explicitOutputOptionRequired
	}

	var config = try loadConfig(configURL, bazelURL: explicitBazelURL)
	config = config.configByAppendingPathFilters(arguments.additionalPathFilters)
	if let project = projectDocument.project {
	config = config.configByResolvingInheritedSettingsFromProject(project)
	}
	if let extraFlags = arguments.buildOptions {
	config.options[.BazelBuildOptionsDebug].appendProjectValue(extraFlags)
	config.options[.BazelBuildOptionsRelease].appendProjectValue(extraFlags)
	}

	let workspaceRootURL: URL
	let projectWorkspaceRootURL = projectDocument.workspaceRootURL
	if let workspaceRootOverride = arguments.workspaceRootOverride {
	workspaceRootURL = URL(fileURLWithPath: workspaceRootOverride, isDirectory: true)
	if !isExistingDirectory(workspaceRootURL) {
	throw HeadlessModeError.invalidWorkspaceRootOverride
	}
	if projectWorkspaceRootURL != nil {
	print("Overriding project workspace root (\(projectWorkspaceRootURL!.path)) with " +
	"command-line parameter (\(workspaceRootOverride))")
	}
	} else {
	guard let projectWorkspaceRootURL = projectWorkspaceRootURL else {
	throw HeadlessModeError.invalidProjectFileContents("Invalid workspaceRoot")
	}
	workspaceRootURL = projectWorkspaceRootURL as URL
	}

	if let announcementIdToMarkRead = arguments.announcementId {
	guard
	let announcement = try Announcement.loadAnnouncement(byId: announcementIdToMarkRead)
	else {
	throw HeadlessModeError.invalidAnnouncementId
	}

	announcement.recordDismissal()
	print("\(announcementIdToMarkRead) has been marked read and will not appear again.")
	}

	let announcement = try? Announcement.getNextUnreadAnnouncement()

	if let announcementToDisplay = announcement, announcementToDisplay.shouldAppearAtTopOfCLIOutput
	{
	print(announcementToDisplay.createCLIOutput())
	}

	print("Generating project into '\(outputFolderURL.path)' using:\n" +
	"\tconfig at '\(configURL.path)'\n" +
	"\tBazel workspace at '\(workspaceRootURL.path)'\n" +
	"\tBazel at '\(config.bazelURL.path)'.\n" +
	"This may take a while.")

	let result = TulsiGeneratorConfigDocument.generateXcodeProjectInFolder(outputFolderURL,
	withGeneratorConfig: config,
	workspaceRootURL: workspaceRootURL,
	messageLog: nil)

	switch result {
	case .success(let url):
	print("Generated project at \(url.path)")
	if arguments.openXcodeOnSuccess {
	print("Opening generated project in Xcode")
	NSWorkspace.shared.open(url)
	}
	case .failure:
	throw HeadlessModeError.generationFailed
	}

	if let announcementToDisplay = announcement,
	!announcementToDisplay.shouldAppearAtTopOfCLIOutput
	{
	print(announcementToDisplay.createCLIOutput())
	}
	}

	// MARK: - Private methods

	private func resolveConfigPath(_ path: String) throws -> (projectURL: URL,
	configURL: URL,
	defaultOutputFolderURL: URL?) {
	let tulsiProjExtension = TulsiProjectDocument.getTulsiBundleExtension()
	let components = path.components(separatedBy: ":")
	if components.count == 2 {
	var pathString = components[0] as NSString
	let projectExtension = pathString.pathExtension
	if projectExtension != tulsiProjExtension {
	pathString = pathString.appendingPathExtension(tulsiProjExtension)! as NSString
	}
	let projectURL = URL(fileURLWithPath: pathString as String)
	let (configURL, defaultOutputFolderURL) = try locateConfigNamed(components[1],
	inTulsiProject: pathString as String)
	return (projectURL, configURL, defaultOutputFolderURL)
	}

	var pathString = path as NSString
	let pathExtension = pathString.pathExtension
	var isProject = pathExtension == tulsiProjExtension
	if !isProject && pathExtension.isEmpty {
	// See if the user provided a Tulsiproj bundle without the extension or if there is a
	// tulsiproj bundle with the same name as the given directory.
	let projectPath = pathString.appendingPathExtension(tulsiProjExtension)!
	if isExistingDirectory(URL(fileURLWithPath: projectPath, isDirectory: true)) {
	isProject = true
	pathString = projectPath as NSString
	} else {
	let projectName = (pathString.lastPathComponent as NSString).appendingPathExtension(tulsiProjExtension)!
	let projectWithinPath = pathString.appendingPathComponent(projectName)
	if isExistingDirectory(URL(fileURLWithPath: projectWithinPath, isDirectory: true)) {
	isProject = true
	pathString = projectWithinPath as NSString
	}
	}
	}
	if isProject {
	let project = pathString.lastPathComponent as NSString
	let projectName = project.deletingPathExtension
	let (configURL, defaultOutputFolderURL) = try locateConfigNamed(projectName,
	inTulsiProject: pathString as String)
	let projectURL = URL(fileURLWithPath: pathString as String)
	return (projectURL, configURL, defaultOutputFolderURL)
	}

	throw HeadlessModeError.invalidConfigPath("The given config is invalid")
	}

	private func locateConfigNamed(_ configName: String,
	inTulsiProject tulsiProj: String) throws -> (configURL: URL, defaultOutputFolderURL: URL?) {
	let tulsiProjectURL = URL(fileURLWithPath: tulsiProj, isDirectory: true)
	if !isExistingDirectory(tulsiProjectURL) {
	throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not exist")
	}

	let configDirectoryURL = tulsiProjectURL.appendingPathComponent(TulsiProjectDocument.ProjectConfigsSubpath)
	if !isExistingDirectory(configDirectoryURL) {
	throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not contain any configs")
	}

	let configFilename: String
	if configName.hasSuffix(TulsiGeneratorConfig.FileExtension) {
	configFilename = configName
	} else {
	configFilename = "\(configName).\(TulsiGeneratorConfig.FileExtension)"
	}

	let configFileURL = configDirectoryURL.appendingPathComponent(configFilename)
	if FileManager.default.isReadableFile(atPath: configFileURL.path) {
	return (configFileURL, tulsiProjectURL.deletingLastPathComponent())
	}
	throw HeadlessModeError.invalidConfigPath("The given Tulsi project does not contain a Tulsi config named \(configName).")
	}

	private func isExistingDirectory(_ url: URL) -> Bool {
	var isDirectory = ObjCBool(false)
	if !FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory) {
	return false
	}
	return isDirectory.boolValue
	}

	private func loadConfig(_ url: URL, bazelURL: URL?) throws -> TulsiGeneratorConfig {
	let config: TulsiGeneratorConfig
	do {
	config = try TulsiGeneratorConfig.load(url, bazelURL: bazelURL)
	} catch TulsiGeneratorConfig.ConfigError.badInputFilePath {
	throw HeadlessModeError.invalidConfigFileContents("Failed to read config file at \(url.path)")
	} catch TulsiGeneratorConfig.ConfigError.failedToReadAdditionalOptionsData(let info) {
	throw HeadlessModeError.invalidConfigFileContents("Failed to read per-user config file: \(info)")
	} catch TulsiGeneratorConfig.ConfigError.deserializationFailed(let info) {
	throw HeadlessModeError.invalidConfigFileContents("Config file at \(url.path) is invalid: \(info)")
	} catch {
	throw HeadlessModeError.invalidConfigFileContents("Unexpected exception reading config file at \(url.path)")
	}

	if !config.bazelURL.isFileURL {
	throw HeadlessModeError.invalidBazelPath
	}
	return config
	}
	}