Tag: Swift

Git hooks are scripts written in any scripting language and are triggered when important actions occur. Hooks are stored in the repository’s .git/hooks folder. The script needs to have an appropriate filename without a path extension and also have executable permissions. Push event is an excellent time for triggering unit-tests and making sure local changes have not broken any. Therefore we’ll look into how to create a pre-push script for an iOS project in Swift.

Quick introduction to scripts written in Swift

Setting up a simple script in Swift follows steps familiar from other languages. The script file needs to start with #!/usr/bin/swift followed by the actual script. A simple example script can look like this.

	#!/usr/bin/swift
	print("Example")

view raw Script.swift hosted with ❤ by GitHub

The command for running the script is swift Script.swift (if the filename is Script.swift). Another way is making the script executable by adding executable permissions to the file by running chmod +x Script.swift command. Then the script can be run with ./Script.swift (makes sense to drop the file extension).

Building a Xcode project for testing

The pre-push script contains of 3 steps: building the project for testing, running tests, and finally printing out the code coverage results. The first step catches build errors, the second step test failures, and the third step prints out code coverage results. Code coverage can be enabled in the scheme’s test action or adding -enableCodeCoverage YES to the xcodebuild command. Before we jump into creating a xcodebuild command with correct arguments then we’ll need to tackle the problem of calling the xcodebuild command line application from the Swift script. Command line applications can be invoked with the Foundation’s Process class. We’ll add an extension which deals with launching a specified command with zsh and printing out the standard output and error.

	extension Process {
	@discardableResult
	static func runZshCommand(_ command: String) -> Int32 {
	let process = Process()
	process.launchPath = "/bin/zsh"
	process.arguments = ["-c", command]
	process.standardOutput = {
	let pipe = Pipe()
	pipe.fileHandleForReading.readabilityHandler = { handler in
	guard let string = String(data: handler.availableData, encoding: .utf8), !string.isEmpty else { return }
	print(string)
	}
	return pipe
	}()
	process.standardError = {
	let pipe = Pipe()
	pipe.fileHandleForReading.readabilityHandler = { handler in
	guard let string = String(data: handler.availableData, encoding: .utf8), !string.isEmpty else { return }
	print(string)
	}
	return pipe
	}()
	process.launch()
	process.waitUntilExit()
	(process.standardOutput as! Pipe).fileHandleForReading.readabilityHandler = nil
	(process.standardError as! Pipe).fileHandleForReading.readabilityHandler = nil
	return process.terminationStatus
	}
	}

view raw Process.swift hosted with ❤ by GitHub

The next step in the script is to define the project related configuration and create the xcodebuild command. All the user defined arguments are wrapped in quotes for avoiding any issues with whitespaces. The command is pretty straight-forward. If there are any build errors then the result code is not equal to 0. Then we can use the same error code for exiting the Swift script with exit() function.

	#!/usr/bin/swift
	import Foundation
	let projectType = "-workspace"
	let projectPath = "SignalPath.xcworkspace"
	let scheme = "SignalPathiOS"
	let destinationDevice = "platform=iOS Simulator,name=iPhone 11 Pro Max"
	let resultBundlePath = "PrePush.xcresult"
	removeResultBundle(at: resultBundlePath)
	print("Building for testing…")
	let buildCommand = [
	"xcodebuild",
	"build-for-testing",
	"-quiet",
	projectType, projectPath.wrappedInQuotes,
	"-scheme", scheme.wrappedInQuotes,
	"-destination", destinationDevice.wrappedInQuotes
	].joined(separator: " ")
	let buildStatus = Process.runZshCommand(buildCommand)
	if buildStatus != 0 {
	exit(buildStatus)
	}
	extension String {
	var wrappedInQuotes: String {
	return "\"\(self)\""
	}
	}

view raw pre-push-1.swift hosted with ❤ by GitHub

Running unit-tests

The command used for running unit-tests is fairly similar. Instead of build-without-testing we are using test-without-building argument and additionally provide a path where the result bundle is written to. This bundle contains information about the test run. Note that this path must not exist, otherwise xcodebuild stops with an error. Therefore we delete the existing file before running the command. Moreover, when there is a failure, we’ll clean up the path as well – pre-push script should not leave any temporary files.

	removeResultBundle(at: resultBundlePath)
	print("Running tests…")
	let testCommand = [
	"xcodebuild",
	"test-without-building",
	"-quiet",
	projectType, projectPath.wrappedInQuotes,
	"-scheme", scheme.wrappedInQuotes,
	"-destination", destinationDevice.wrappedInQuotes,
	"-resultBundlePath", resultBundlePath.wrappedInQuotes
	].joined(separator: " ")
	let testStatus = Process.runZshCommand(testCommand)
	if testStatus != 0 {
	removeResultBundle(at: resultBundlePath)
	exit(testStatus)
	}
	func removeResultBundle(at path: String) {
	guard FileManager.default.fileExists(atPath: path) else { return }
	try? FileManager.default.removeItem(atPath: path)
	}

view raw pre-push-2.swift hosted with ❤ by GitHub

Printing out code coverage

Last step is optional but it is nice to see code coverage information when pushing changes to a server. Xcode provides a command line application for viewing coverage data in human readable form. One of the options is printing out code coverage per target which gives a nice and concise overview.

	let coverageCommand = [
	"xcrun",
	"xccov",
	"view",
	"–only-targets",
	"–report", resultBundlePath.wrappedInQuotes
	].joined(separator: " ")
	Process.runZshCommand(coverageCommand)
	removeResultBundle(at: resultBundlePath)
	print("Success")
	exit(0)

view raw pre-push-3.swift hosted with ❤ by GitHub

Summary

We looked into how to create a pre-push script in Swift. It called other command line applications for building the project, running the tests, and printing out code coverage information. The full script is available below, feel free to copy-paste it to your projects. The one last thing to consider is adding an alias in Terminal for easy installation: alias xcode_pre_push_add='cp ~/Dev/pre-push .git/hooks/pre-push && mate .git/hooks/pre-push' This just copies it from predefined location to the repository checkout and opens it in an editor for setting project related settings (replace mate with any editor).

	#!/usr/bin/swift
	import Foundation
	let projectType = "-workspace"
	let projectPath = "SignalPath.xcworkspace"
	let scheme = "SignalPathiOS"
	let destinationDevice = "platform=iOS Simulator,name=iPhone 11 Pro Max"
	let resultBundlePath = "PrePush.xcresult"
	print("Building for testing…")
	let buildCommand = [
	"xcodebuild",
	"build-for-testing",
	"-quiet",
	projectType, projectPath.wrappedInQuotes,
	"-scheme", scheme.wrappedInQuotes,
	"-destination", destinationDevice.wrappedInQuotes
	].joined(separator: " ")
	let buildStatus = Process.runZshCommand(buildCommand)
	if buildStatus != 0 {
	exit(buildStatus)
	}
	removeResultBundle(at: resultBundlePath)
	print("Running tests…")
	let testCommand = [
	"xcodebuild",
	"test-without-building",
	"-quiet",
	projectType, projectPath.wrappedInQuotes,
	"-scheme", scheme.wrappedInQuotes,
	"-destination", destinationDevice.wrappedInQuotes,
	"-resultBundlePath", resultBundlePath.wrappedInQuotes
	].joined(separator: " ")
	let testStatus = Process.runZshCommand(testCommand)
	if testStatus != 0 {
	removeResultBundle(at: resultBundlePath)
	exit(testStatus)
	}
	let coverageCommand = [
	"xcrun",
	"xccov",
	"view",
	"–only-targets",
	"–report", resultBundlePath.wrappedInQuotes
	].joined(separator: " ")
	Process.runZshCommand(coverageCommand)
	removeResultBundle(at: resultBundlePath)
	print("Success")
	exit(0)
	// MARK: –
	extension String {
	var wrappedInQuotes: String {
	return "\"\(self)\""
	}
	}
	extension Process {
	@discardableResult
	static func runZshCommand(_ command: String) -> Int32 {
	let process = Process()
	process.launchPath = "/bin/zsh"
	process.arguments = ["-c", command]
	process.standardOutput = {
	let pipe = Pipe()
	pipe.fileHandleForReading.readabilityHandler = { handler in
	guard let string = String(data: handler.availableData, encoding: .utf8), !string.isEmpty else { return }
	print(string)
	}
	return pipe
	}()
	process.standardError = {
	let pipe = Pipe()
	pipe.fileHandleForReading.readabilityHandler = { handler in
	guard let string = String(data: handler.availableData, encoding: .utf8), !string.isEmpty else { return }
	print(string)
	}
	return pipe
	}()
	process.launch()
	process.waitUntilExit()
	(process.standardOutput as! Pipe).fileHandleForReading.readabilityHandler = nil
	(process.standardError as! Pipe).fileHandleForReading.readabilityHandler = nil
	return process.terminationStatus
	}
	}
	func removeResultBundle(at path: String) {
	guard FileManager.default.fileExists(atPath: path) else { return }
	try? FileManager.default.removeItem(atPath: path)
	}

view raw pre-push.swift hosted with ❤ by GitHub

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.