construct higher command line apps and instruments utilizing Swift?

Operating Swift recordsdata as scripts

It’s attainable to run a Swift file straight from the command line should you add a hashbang to the start of the file. This manner you do not have to manually compile the code utilizing the swiftc command. You may merely give the file the executable permission flag and the system will name the Swift REPL beneath the hood, so our app could be evaluated robotically. 🔨

#!/usr/bin/env swift

print("Howdy, world!")

For instance this important.swift file above could be marked as an executable file, and we are able to merely name it by way of the ./important.swift command in a while (you simply have to make use of chmod just one time).

chmod +x important.swift 
./important.swift  

The great thing about this methodology is that you may quickly take a look at your Swift command line snippets. You may even place the completed Swift scripts beneath the /usr/native/bin/ listing with out the swift file extension to make them accessible “globally” on your working system person. 💪

Utilizing command line arguments in Swift

The CommandLine enum makes it very simple to fetch the arguments handed to our Swift software or script. You may entry each argument utilizing the arguments variable as an array of Strings, however additionally it is attainable to get the uncooked information utilizing the argc and unsafeArgv properties.

#!/usr/bin/env swift


let script = CommandLine.arguments[0]
print("Script:", script)


let inputArgs = CommandLine.arguments.dropFirst()
print("Variety of arguments:", inputArgs.depend)

print("Arguments:")
for arg in inputArgs {
    print("-", arg)
}

It’s best to observe that the primary argument is all the time the trail of the present script, so if you’re solely searching for the enter arguments you should utilize the dropFirst() methodology to return a subset of the enter strings. Often every argument is separated by an area character.

./important.swift hi there world

In Xcode you’ll be able to add customized arguments beneath the Edit Scheme… menu merchandise whenever you click on on the present scheme, search for the Arguments tab and use the Arguments Handed On Launch part.

Course of data and setting in Swift

Similar to we are able to entry command line arguments, it’s attainable to look at the present course of together with some {hardware} data and setting variables.

#!/usr/bin/env swift
import Basis

let data = ProcessInfo.processInfo

print("Course of data")
print("Course of identifier:", data.processIdentifier)
print("System uptime:", data.systemUptime)
print("Globally distinctive course of id string:", data.globallyUniqueString)
print("Course of title:", data.processName)

print("Software program data")
print("Host title:", data.hostName)
print("OS main model:", data.operatingSystemVersion.majorVersion)
print("OS model string", data.operatingSystemVersionString)

print("{Hardware} data")
print("Energetic processor depend:", data.activeProcessorCount)
print("Bodily reminiscence (bytes)", data.physicalMemory)


print("Arguments")
print(ProcessInfo.processInfo.arguments)

print("Setting")

print(data.setting)

The setting variables property is a Dictionary the place each the keys and the values can be found as strings, so that you might need to parse them if you’re searching for completely different worth varieties. You may arrange setting customized variables in Xcode similar to arguments, or you’ll be able to move them by way of the command line earlier than you execute the Swift script utilizing the export command.

Commonplace enter and output in Swift

You need to use the print perform to write down textual content to the usual output, however you need to observe that the print perform has a variadic objects definition, so you’ll be able to move round a number of arguments and a customized separator & terminator parameter to show extra superior outputs.

There’s additionally a regular error stream, which is a part of the commonplace streams after all, however what’s fascinating about it’s that you may additionally write to this channel by the FileHandle.standardError property there may be fairly a chic answer on a Stack Overflow thread initially created by Rob Napier, I’ll embody that one right here as properly. 🙏

One other nice function of the print perform is the to parameter, which may settle for a customized TextOutputStream so you’ll be able to wrap the stderr stream in a customized object or you may as well create customized output handlers and separate your print statements e.g. by context should you want.

#!/usr/bin/env swift
import Basis


print("This", "is", "enjoyable", separator: "-", terminator: "!")


"This goes to the usual error output"
    .information(utilizing: .utf8)
    .map(FileHandle.standardError.write)


last class StandardErrorOutputStream: TextOutputStream {
    func write(_ string: String) {
        FileHandle.standardError.write(Knowledge(string.utf8))
    }
}

var outputStream = StandardErrorOutputStream()
print("That is additionally an error", to: &outputStream)



func clear() {
    print("u{1B}[2J")
    print("u{1B}[(1);(0)H", terminator: "")
}

print("foooooooooooooooooooooo")
clear()
print("Hello, world!")



print("u{1b}[31;1mu{1b}[40;1m("Hello, world!")u{1b}[m")
print("u{1b}[32;1m("Hello, world!")u{1b}[m")


print("Please enter your input:")
guard let input = readLine(strippingNewline: true) else {
    fatalError("Missing input")
}
print(input)

The second half of the snippet is full of ANSI escape codes which I like quite a lot, because it can make our terminal output quite beautiful. The only problem is that they don’t work in Xcode at all (come-on Apple, please support this…). You can clear the console or change the background / foreground color of the output by using these codes.

There are quite a lot of libraries on GitHub that you can use to print colorful output, for example ColorizeSwift, ANSITerminal, ANSIEscapeCode and many more cool ones.

The very last thing that I’d like to show you is the readLine function, which you can use to read a line from the standard input. This comes handy if you need to get user input from the command line.

Use an argument parser library

If you are looking for a type-safe argument parser written in Swift, you should definitely take a look at the Swift Argument Parser library. It is created and maintained by Apple, so it’s kind of an official solution for this particular issue, but IMHO it lacks some advanced features.

This is the main reason why I prefer the Vapor command API built on top of the ConsoleKit library. Both libraries can parse arguments, options and flags, but ConsoleKit is also capable of displaying progress indicators, it features multiple command groups, secure input, auto-completion, multiple log levels and many more.

import Foundation
import ConsoleKit

final class HelloCommand: Command {
        
    struct Signature: CommandSignature {

        @Argument(name: "name", help: "The name to say hello")
        var name: String

        @Option(name: "greeting", short: "g", help: "Greeting used")
        var greeting: String?

        @Flag(name: "capitalize", short: "c", help: "Capitalizes the name")
        var capitalize: Bool
    }

    static var name = "hello"
    let help = "This command will say hello to a given name."

    func run(using context: CommandContext, signature: Signature) throws {
        let greeting = signature.greeting ?? "Hello"
        var name = signature.name
        if signature.capitalize {
            name = name.capitalized
        }
        print("(greeting) (name)!")
        
        
        let bar = context.console.progressBar(title: "Hello")
        bar.start()
        
        bar.succeed()
        
        
        let foo = context.console.ask("What?")
        print(foo)
        
        
        let baz = context.console.ask("Secure what?", isSecure: true)
        print(baz)
        
        
        let c = context.console.choose("Make a choice", from: ["foo", "bar", "baz"])
        print(c)

        
    }
}


import Basis
import ConsoleKit

let console: Console = Terminal()
var enter = CommandInput(arguments: CommandLine.arguments)
var context = CommandContext(console: console, enter: enter)

var instructions = Instructions(enableAutocomplete: true)
instructions.use(HelloCommand(), as: HelloCommand.title, isDefault: false)

do {
    let group = instructions.group(assist: "Utilizing ConsoleKit with out Vapor.")
    attempt console.run(group, enter: enter)
}
catch {
    console.error("(error)")
    exit(1)
}

You need to use each answer by the Swift Package deal Supervisor, the setup course of is kind of simple, you may discover extra tutorials in regards to the Swift Argument Parser and I feel that it’s tougher to search out correct docs for ConsoleKit, so yeah… anyway, they’re nice libraries you will not remorse utilizing them. 😉

Make the most of the Swift Package deal Supervisor

The Swift Package deal Supervisor is without doubt one of the smartest thing in regards to the Swift programming language. I actually like it and I take advantage of it virtually day-after-day. The truth that the bundle manifest file is outlined utilizing Swift itself makes it simple to make use of & perceive.

import PackageDescription

let bundle = Package deal(
    title: "myProject",
    platforms: [
        .macOS(.v10_15)
    ],
    dependencies: [
        .package(url: "https://github.com/vapor/console-kit", from: "4.1.0"),
    ],
    targets: [
        .executableTarget(name: "myProject",dependencies: [
            .product(name: "ConsoleKit", package: "console-kit"),
        ]),
        .testTarget(title: "myProjectTests", dependencies: ["myProject"]),
    ]
)

The bundle supervisor developed rather a lot throughout the previous few months, should you check out the Swift Evolution dashboard you’ll be able to monitor these adjustments, the newest replace was the introduction of customized, user-defined Package deal Collections, however if you’re searching for packages you’ll be able to all the time check out the Swift Package deal Index web site. 👍