Swift Package deal Supervisor tutorial – The.Swift.Dev.

Swift Package deal Supervisor fundamentals

To start with, please verify your Swift model in your gadget earlier than we bounce on this tutorial will solely work with the most recent toolchain, so you will want Swift 5.2 or newer.

Apple Swift model 5.2.2 (swiftlang-1103.0.32.6 clang-1103.0.32.51)
Goal: x86_64-apple-darwin19.4.0

Creating apps

All of the exhausting work is finished by the swift bundle command. You possibly can enter that right into a terminal window and see the obtainable sub-commands. To generate a brand new bundle it is best to go together with the init command, if you happen to do not present a kind flag, by default it will create a library, however this time we would wish to make an executable software.

swift bundle init --type executable
swift construct
swift run my-app

The compiler can construct your supply information with the assistance of the swift construct command. The executable file goes to be positioned someplace underneath the .construct listing, if you happen to run the newly created software with the swift run my-app command, it is best to see the fundamental Hiya, world! message.

Congratulations to your first command line Swift software!

Now it is best to do some precise coding. Normally your swift supply information ought to be underneath the Sources listing, nonetheless you may need to create some reusable elements to your app. So let’s put together for that situation by beginning a model new library.

Making a library

We begin with the init command, however this time we do not specify the kind. We truly may enter swift bundle init --type library however that is means too could phrases to sort. Additionally as a result of we’re making a library, the SPM software goes to supply us some primary assessments, let’s run them too with the swift check command. 😜

swift bundle init
swift check
# swift check --help
# swift check --filter <test-target>.<test-case>/<check>

If you happen to verify the file construction now you will not discover a principal.swift file contained in the supply folder, however as an alternative of this you will get an instance unit check underneath the Assessments listing.

Now know the fundamentals. You’ve an instance software and a library, so let’s join them along with the assistance of the Swift Package deal Supervisor Manifest API!

The Manifest API – Package deal.swift

Each SPM bundle has a Package deal.swift manifest file inside it. On this manifest file you may outline all of your dependencies, targets and even the precise supply information to your challenge. On this part I am going to educate you the fundamentals of the manifest file.

Software model

To start with if you wish to assist the brand new manifest file format (aka. Swift 4 model), you need to set the swift-tools-version as remark in your manifest file.

// swift-tools-version:5.2

Now you are able to work with the model new manifest API.

Dependencies

Let’s simply add our library as a dependency for the principle software first by creating a brand new bundle dependency contained in the Package deal.swift file. The primary argument is a bundle url string, which generally is a native file path or a distant url (normally a github repo hyperlink). Notice that it is best to add your dependency to the targets as nicely. Normally the particular title of a bundle is outlined contained in the library manifest file.

import PackageDescription

let bundle = Package deal(
    title: "my-app",
    dependencies: [
        .package(url: "../my-lib", .branch("master")),
    ],
    targets: [
        .target(name: "my-app", dependencies: [
            .product(name: "my-lib", package: "my-lib"),
        ]),
    ]
)

Now if you happen to run swift construct you will fail to construct your sources. That is as a result of the SPM solely works with git repositories. This implies you need to create a repository to your library. Let’s transfer to the listing of the library and run the next instructions.

git init
git add .
git commit -m 'preliminary'

You must also observe that we specified the department within the bundle dependencies. You should use model numbers, and even commit hashes too. All of the obtainable choices are nicely written contained in the manifest API redesign proposal doc.

Now let’s return to the applying listing and replace the dependencies with the swift bundle replace command. This time it is going to have the ability to fetch, clone and at last resolve our dependency.

You possibly can construct and run, nonetheless we have forgot to set the entry stage of our struct inside our library to public, so nothing goes to be seen from that API.

public struct my_lib {
    public var textual content = "Hiya, World!"

    public init() {}
}

Let’s do some modifications and commit them into the library’s principal department.

git add .
git commit -m 'entry stage repair'

You are prepared to make use of the lib within the app, change the principle.swift file like this.

import my_lib

print(my_lib().textual content)

Replace the dependencies once more, and let’s do a launch construct this time.

swift bundle replace
swift construct -c launch
swift run -c launch

With the -c or --configuration flag you can also make a launch construct.

Merchandise and targets

By default the SPM works with the next goal directories:

Common targets: bundle root, Sources, Supply, src, srcs. Take a look at targets: Assessments, bundle root, Sources, Supply, src, srcs.

This implies, that if you happen to create .swift information inside these folders, these sources shall be compiled or examined, relying on the file location. Additionally the generated manifest file comprises just one construct goal (like Xcode targets), however generally you need to create a number of apps or libraries from the identical bundle. Let’s change our Package deal.swift file a little bit bit, and see how can we make a model new goal.

import PackageDescription

let bundle = Package deal(
    title: "my-app",
    dependencies: [
        .package(url: "../my-lib", .branch("master")),
        .package(url: "https://github.com/kylef/Commander", from: "0.8.0"),
    ],
    targets: [
        .target(name: "my-app", dependencies: [
            .product(name: "my-lib", package: "my-lib"),
        ]),
        .goal(title: "my-cmd", dependencies: [
            .product(name: "Commander", package: "Commander"),
        ], path: "./Sources/my-cmd", sources: ["main.swift"]),
    ]
)

We simply created a brand new dependency from GitHub, and a model new goal which can include solely the principal.swift file from the Sources/my-cmd listing. Now let’s create this listing and add the supply code for the brand new app.

import Basis
import Commander

let principal = command { (title:String) in
    print("Hiya, (title.capitalized)!")
}

principal.run()

Construct the challenge with swift construct and run the newly created app with one additional title parameter. Hopefully you will see one thing like this.

swift run my-cmd visitor
# Hiya, Visitor!

So we simply made a model new executable goal, nonetheless if you would like to show your targets for different packages, it is best to outline them as merchandise as nicely. If you happen to open the manifest file for the library, you will see that there’s a product outlined from the library goal. This fashion the bundle supervisor can hyperlink the product dependencies primarily based on the given product title.

You possibly can outline static or dynamic libraries, nonetheless it is strongly recommended to make use of automated so the SPM can determine acceptable linkage.

import PackageDescription

let bundle = Package deal(
    title: "my-lib-package",
    merchandise: [
        .library(name: "my-lib", targets: ["my-lib"]),
        
    ],
    dependencies: [
        
    ],
    targets: [
        .target(name: "my-lib", dependencies: []),
        .testTarget(title: "my-libTests", dependencies: ["my-lib"]),
    ]
)

Deployment goal, different construct flags

Typically you will have to specify a deployment goal to your bundle. Now that is doable with the Swift Package deal Supervisor (it was buggy a log time in the past), you simply have to supply some additional arguments for the compiler, through the construct section.

swift construct -Xswiftc "-target" -Xswiftc "x86_64-apple-macosx10.12"

Additionally if you want to outline construct flags, that is doable too.

swift construct -Xswiftc "-D" -Xswiftc "DEBUG"

Now in your supply code you may verify for the existence of the DEBUG flag.

#if DEBUG
    print("debug mode")
#endif

If you wish to know extra in regards to the construct course of, simply sort swift construct --help and you will see your obtainable choices for the construct command.

This was SPM in a nutshell. Really we now have lined extra than simply the fundamentals, we deep-dived a little bit into the Swift Package deal Supervisor, now you should be aware of targets, merchandise and a lot of the obtainable instructions, however there’s all the time extra to be taught. So if you wish to know much more about this wonderful software, it is best to verify the Swift evolution dashboard for more information. 😉