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

Dependencies

Let's simply add our library as a dependency for the principle utility 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 effectively. Normally the particular identify of a bundle is outlined contained in the library manifest file.

import PackageDescription

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

Now in the event you 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 it's important to create a repository on 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 also needs to notice that we specified the department within the bundle dependencies. You should use model numbers, and even commit hashes too. All of the out there choices are effectively written contained in the manifest api redesign proposal doc.

Now let's return to the appliance listing and replace the dependencies with the swift bundle replace command. This time it is going to have the ability to fetch, clone and eventually 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 = "Hi there, World!"

    public init() {}
}

Let's do some adjustments and commit them into the library's fundamental 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. Check targets: Checks, bundle root, Sources, Supply, src, srcs.

This implies, that in the event you create .swift recordsdata inside these folders, these sources might 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 wish 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(
    identify: "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(identify: "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 is able to include solely the fundamental.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 fundamental = command { (identify:String) in
    print("Hi there, (identify.capitalized)!")
}

fundamental.run()

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

swift run my-cmd visitor

So we simply made a model new executable goal, nonetheless if you would like to reveal your targets for different packages, it is best to outline them as merchandise as effectively. 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 manner the bundle supervisor can hyperlink the product dependencies primarily based on the given product identify.

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

import PackageDescription

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

Deployment goal, different construct flags

Generally you will must specify a deployment goal on your bundle. Now that is attainable with the Swift Package deal Supervisor (it was buggy a log time in the past), you simply have to offer some additional arguments for the compiler, in the course of the construct section.

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

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

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

Now in your supply code you possibly can 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 kind swift construct --help and you may see your out there choices for the construct command.

Yet another factor

You possibly can generate Xcode tasks with the Swift Package deal Supervisor.

swift bundle generate-xcodeproj

This was SPM in a nutshell. Truly now we have coreverd 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 many of the out there instructions, however there may be at all times extra to study. So if you wish to know much more about this superb device, it is best to verify the Swift evolution dashboard for more information. Take pleasure in. 😉