Swiftpack.co - Package - kareman/SwiftShell

Run shell commands | Parse command line arguments | Handle files and directories


Swift 4 | Swift 3 | Swift 2

SwiftShell logo

Build Status Platforms Swift Package Manager Carthage compatible Twitter: @nottoobadsw

SwiftShell

A library for creating command-line applications and running shell commands in Swift.

Features

  • [x] run commands, and handle the output.
  • [x] run commands asynchronously, and be notified when output is available.
  • [x] access the context your application is running in, like environment variables, standard input, standard output, standard error, the current directory and the command line arguments.
  • [x] create new such contexts you can run commands in.
  • [x] handle errors.
  • [x] read and write files.

See also

Table of Contents

Example

Print line numbers

#!/usr/bin/env swiftshell

import SwiftShell

do {
	// If there is an argument, try opening it as a file. Otherwise use standard input.
	let input = try main.arguments.first.map {try open($0)} ?? main.stdin

	input.lines().enumerated().forEach { (linenr,line) in 
		print(linenr+1, ":", line) 
	}

	// Add a newline at the end.
	print("")
} catch {
	exit(error)
}

Launched with e.g. cat long.txt | print_linenumbers.swift or print_linenumbers.swift long.txt this will print the line number at the beginning of each line.

Others

Context

All commands (a.k.a. processes) you run in SwiftShell need context: environment variables, the current working directory, standard input, standard output and standard error (standard streams).

public struct CustomContext: Context, CommandRunning {
	public var env: [String: String]
	public var currentdirectory: String
	public var stdin: ReadableStream
	public var stdout: WritableStream
	public var stderror: WritableStream
}

You can create a copy of your application's context: let context = CustomContext(main), or create a new empty one: let context = CustomContext(). Everything is mutable, so you can set e.g. the current directory or redirect standard error to a file.

Main context

The global variable main is the Context for the application itself. In addition to the properties mentioned above it also has these:

  • public var encoding: String.Encoding The default encoding used when opening files or creating new streams.
  • public let tempdirectory: String A temporary directory you can use for temporary stuff.
  • public let arguments: [String] The arguments used when launching the application.
  • public let path: String The path to the application.

main.stdout is for normal output, like Swift's print function. main.stderror is for error output, and main.stdin is the standard input to your application, provided by something like somecommand | yourapplication in the terminal.

Commands can't change the context they run in (or anything else internally in your application) so e.g. main.run("cd", "somedirectory") will achieve nothing. Use main.currentdirectory = "somedirectory" instead, this changes the current working directory for the entire application.

Example

Prepare a context similar to a new macOS user account's environment in the terminal (from kareman/testcommit):

import SwiftShell
import Foundation

extension Dictionary where Key:Hashable {
	public func filterToDictionary <C: Collection> (keys: C) -> [Key:Value]
		where C.Iterator.Element == Key, C.IndexDistance == Int {

		var result = [Key:Value](minimumCapacity: keys.count)
		for key in keys { result[key] = self[key] }
		return result
	}
}

// Prepare an environment as close to a new OS X user account as possible.
var cleanctx = CustomContext(main)
let cleanenvvars = ["TERM_PROGRAM", "SHELL", "TERM", "TMPDIR", "Apple_PubSub_Socket_Render", "TERM_PROGRAM_VERSION", "TERM_SESSION_ID", "USER", "SSH_AUTH_SOCK", "__CF_USER_TEXT_ENCODING", "XPC_FLAGS", "XPC_SERVICE_NAME", "SHLVL", "HOME", "LOGNAME", "LC_CTYPE", "_"]
cleanctx.env = cleanctx.env.filterToDictionary(keys: cleanenvvars)
cleanctx.env["PATH"] = "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"

// Create a temporary directory for testing.
cleanctx.currentdirectory = main.tempdirectory

Streams

The protocols ReadableStream and WritableStream in Context above can read and write text from/to commands, files or the application's own standard streams. They both have an .encoding property they use when encoding/decoding text.

You can use let (input,output) = streams() to create a new pair of streams. What you write to input you can read from output.

FileSmith's WritableFile and ReadableFile are streams too, and can be used as stdin, stdout and stderror in SwiftShell Contexts, including main.

WritableStream

When writing to a WritableStream you normally use .print which works exactly like Swift's built-in print function:

main.stdout.print("everything is fine")
main.stderror.print("no wait, something went wrong ...")

let writefile = try open(forWriting: path) // WritableStream
writefile.print("1", 2, 3/5, separator: "+", terminator: "=")

If you want to be taken literally, use .write instead. It doesn't add a newline and writes exactly and only what you write:

writefile.write("Read my lips:")

You can close the stream, so anyone who tries to read from the other end won't have to wait around forever:

writefile.close()

ReadableStream

When reading from a ReadableStream you can read everything at once:

let readfile = try open(path) // ReadableStream
let contents = readfile.read()

This will read everything and wait for the stream to be closed if it isn't already.

You can also read it asynchronously, that is read whatever is in there now and continue without waiting for it to be closed:

while let text = main.stdin.readSome() {
	// do something with ‘text’...
}

.readSome() returns String? - if there is anything there it returns it, if the stream is closed it returns nil, and if there is nothing there and the stream is still open it will wait until either there is more content or the stream is closed.

Another way to read asynchronously is to use the lines method which creates a lazy sequence of Strings, one for each line in the stream:

for line in main.stdin.lines() {
	// ...
}

Or instead of stopping and waiting for any output you can be notified whenever there is something in the stream:

main.stdin.onOutput { stream in
	// ‘stream’ refers to main.stdin
}

Data

In addition to text, streams can also handle raw Data:

let data = Data(...)
writer.write(data: data)
reader.readSomeData()
reader.readData() 

Commands

All Contexts (CustomContext and main) implement CommandRunning, which means they can run commands using themselves as the Context. ReadableStream and String can also run commands, they use main as the Context and themselves as .stdin. As a shortcut you can just use run(...) instead of main.run(...)

There are three different ways of running a command:

Run

The simplest is to just run the command, wait until it's finished and return the results:

let result1 = run("/usr/bin/executable", "argument1", "argument2")
let result2 = run("executable", "argument1", "argument2")

If you don't provide the full path to the executable, then SwiftShell will try to find it in any of the directories in the PATH environment variable.

run returns the following information:

/// Output from a `run` command.
public final class RunOutput {

	/// The error from running the command, if any.
	let error: CommandError?

	/// Standard output, trimmed for whitespace and newline if it is single-line.
	let stdout: String

	/// Standard error, trimmed for whitespace and newline if it is single-line.
	let stderror: String

	/// The exit code of the command. Anything but 0 means there was an error.
	let exitcode: Int

	/// Checks if the exit code is 0.
	let succeeded: Bool
}

For example:

let date = run("date", "-u").stdout
print("Today's date in UTC is " + date)

Print output

try runAndPrint("executable", "arg") 

This runs a command like in the terminal, where any output goes to the Context's (main in this case) .stdout and .stderror respectively. If the executable could not be found, was inaccessible or not executable, or the command returned with an exit code other than zero, then runAndPrint will throw a CommandError.

The name may seem a bit cumbersome, but it explains exactly what it does. SwiftShell never prints anything without explicitly being told to.

Asynchronous

let command = runAsync("cmd", "-n", 245).onCompletion { command in
	// be notified when the command is finished.
}
command.stdout.onOutput { stdout in 
	// be notified when the command produces output.	
}

// do something with ‘command’ while it is still running.

try command.finish() // wait for it to finish.

runAsync launches a command and continues before it's finished. It returns this:

/// Output from the 'runAsync' methods.
public final class AsyncCommand {
	public let stdout: ReadableStream
	public let stderror: ReadableStream

	/// Is the command still running?
	public var isRunning: Bool

	/// Terminates command.
	public func stop()

	/// Waits for command to finish.
	/// - returns: itself
	/// - throws: `CommandError.returnedErrorCode(command: String, errorcode: Int)` if the exit code is anything but 0.
	public func finish() throws -> AsyncCommand

	/// Waits for command to finish, then returns with exit code.
	public func exitcode() -> Int

	/// Takes a closure to be called when the command has finished.
	/// - Parameter handler: A closure taking this AsyncCommand as input, returning nothing.
	/// - Returns: This AsyncCommand.
	public func onCompletion(_ handler: @escaping (AsyncCommand) -> Void) -> AsyncCommand
}

You can process standard output and standard error, and optionally wait until it's finished and handle any errors.

If you read all of command.stderror or command.stdout it will automatically wait for the command to close its streams (and presumably finish running). You can still call finish() to check for errors.

Parameters

The 3 run functions above take 2 different types of parameters:

(_ executable: String, _ args: Any ...)

If the path to the executable is without any /, SwiftShell will try to find the full path using the which shell command, which searches the directories in the PATH environment variable in order.

The array of arguments can contain any type, since everything is convertible to strings in Swift. If it contains any arrays it will be flattened so only the elements will be used, not the arrays themselves.

try runAndPrint("echo", "We are", 4, "arguments")
// echo "We are" 4 arguments

let array = ["But", "we", "are"]
try runAndPrint("echo", array, array.count + 2, "arguments")
// echo But we are 5 arguments
(bash bashcommand: String)

These are the commands you normally use in the Terminal. You can use pipes and redirection and all that good stuff:

try runAndPrint(bash: "cmd1 arg1 | cmd2 > output.txt")

Note that you can achieve the same thing in pure SwiftShell, though nowhere near as succinctly:

var file = try open(forWriting: "output.txt")
runAsync("cmd1", "arg1").stdout.runAsync("cmd2").stdout.write(to: &file)

Errors

If the command provided to runAsync could not be launched for any reason the program will print the error to standard error and exit, as is usual in scripts. The runAsync("cmd").finish() method throws an error if the exit code of the command is anything but 0:

let command = runAsync("cmd", "-n", 245)
// do something with command.stderror or command.stdoutCommandError
do {
	try command.finish()
} catch CommandError.ReturnedErrorCode(let error) {
	// use error.command or error.errorcode
}

The runAndPrint command can also throw this error, in addition to this one if the command could not be launched:

} catch CommandError.InAccessibleExecutable(let path) {
	// ‘path’ is the full path to the executable
}

Instead of dealing with the values from these errors you can just print them:

} catch {
	print(error)
}

... or if they are sufficiently serious you can print them to standard error and exit:

} catch {
	exit(error)
}

When at the top code level you don't need to catch any errors, but you still have to use try.

Setup

Stand-alone project

If you put Misc/swiftshell-init somewhere in your $PATH you can create a new project with swiftshell-init <name>. This creates a new folder, initialises a Swift Package Manager executable folder structure, downloads the latest version of SwiftShell, creates an Xcode project and opens it. After running swift build you can find the compiled executable at .build/debug/<name>.

Script file using Marathon

First add SwiftShell to Marathon:

marathon add https://github.com/kareman/SwiftShell.git

Then run your Swift scripts with marathon run <name>.swift. Or add #!/usr/bin/env marathon run to the top of every script file and run them with ./<name>.swift.

Swift Package Manager

Add .Package(url: "https://github.com/kareman/SwiftShell", majorVersion: 4) to your Package.swift:

import PackageDescription

let package = Package(
	name: "somecommandlineapp",
	dependencies: [
		.Package(url: "https://github.com/kareman/SwiftShell.git", majorVersion: 4)
		 ]
)

and run swift build.

Carthage

Add github "kareman/SwiftShell" >= 4.0 to your Cartfile, then run carthage update and add the resulting framework to the "Embedded Binaries" section of the application. See Carthage's README for further instructions.

CocoaPods

Add SwiftShell to your Podfile.

pod 'SwiftShell', '>= 4.0.0'

Then run pod install to install it.

License

Released under the MIT License (MIT), http://opensource.org/licenses/MIT

Kåre Morstøl, NotTooBad Software

Github

link
Stars: 456
Help us keep the lights on

Dependencies

Releases

3.0.1 - May 12, 2017

  • Improve error output from exit(...) and non-SwiftShell errors.

3.0.0 - Apr 29, 2017

The readme says it all.

Most notable recent changes:

  • the run(...) functions now return RunOutput instead of a String.

  • many things were renamed to follow standard Swift naming guidelines.

  • Streams can read and write raw data.

  • Support for iOS – but only for Streams (running shell commands is not possible on iOS). This way other projects, like FileSmith, can use Streams. Streams should be their own module, but then they couldn't implement CommandRunning. This will be possible in Swift 4 I believe.

3.0.0-beta.12 - Mar 24, 2017

2.1 - May 8, 2016

  • Have main.tempdirectory use the name of the script/application.

    Fall back to ‘SwiftShell’ if main.path is empty (running in a playground).

  • Allow passing Ints as error codes to "exit".

  • Actually print error messages in release builds.

    Workaround for a compiler bug where passing an NSError to exit in release builds would not print the actual error message.

  • Fix #16 by having WriteableStream use ‘print’ when writing to standard output.

    This way print's buffering when standard output is not a terminal does not rearrange the order in which output is printed when using both 'print' and 'main.stdout.writeln'. See also https://bugs.swift.org/browse/SR-1127 and http://stackoverflow.com/a/13933741/96587 .

  • Add stop func to stop an AsyncShellTask early.

  • Add async callbacks for ReadableStream.onOutput and AsyncShellTask.onCompletion - allows for getting callbacks with data as the AsyncShellTask is running.

  • Add AsyncShellTask.onStringOutput.

Thanks to @kenthinson for implementing the 3 last ones.

2.0.2 - Mar 22, 2016

Silenced all the warnings by replacing __X__ with #x.