Swift Package Manager tutorial – The.Swift.Dev.

Dependencies

Let's simply add our library as a dependency for the primary software first by creating a brand new package deal dependency contained in the Bundle.swift file. The primary argument is a package deal url string, which could be a native file path or a distant url (normally a github repo hyperlink). Notice that you need to add your dependency to the targets as nicely. Often the precise title of a package deal is outlined contained in the library manifest file.

import PackageDescription

let package deal = Bundle(
    title: "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 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 also needs to observe that we specified the department within the package deal dependencies. You should use model numbers, and even commit hashes too. All of the accessible choices are nicely written contained in the manifest api redesign proposal doc.

Now let's return to the appliance listing and replace the dependencies with the swift package deal replace command. This time it is going to have the ability to fetch, clone and eventually resolve our dependency.

You may construct and run, nonetheless we have forgot to set the entry degree 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 = "Hey, World!"

    public init() 

Let's do some adjustments and commit them into the library's primary department.

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

You are prepared to make use of the lib within the app, change the primary.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 package deal replace
swift construct -c launch
swift run -c launch

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

Merchandise and targets

By default the SPM works with the next goal directories:

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

This implies, that in the event you create .swift recordsdata inside these folders, these sources can be compiled or examined, relying on the file location. Additionally the generated manifest file comprises just one construct goal (like Xcode targets), however typically you wish to create a number of apps or libraries from the identical bundle. Let's change our Bundle.swift file just a little bit, and see how can we make a model new goal.

import PackageDescription

let package deal = Bundle(
    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 is able to comprise solely the primary.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 primary = command  (title:String) in
    print("Hey, (title.capitalized)!")


primary.run()

Construct the mission 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

So we simply made a model new executable goal, nonetheless if you would like to show your targets for different packages, you need to outline them as merchandise as nicely. When you open the manifest file for the library, you will see that there's a product outlined from the library goal. This fashion the package deal supervisor can hyperlink the product dependencies based mostly on the given product title.

You may 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 package deal = Bundle(
    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

Generally you will have to specify a deployment goal to your package deal. Now that is attainable with the Swift Bundle Supervisor (it was buggy a log time ago), you simply have to supply 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'll be able to test for the existence of the DEBUG flag.

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

If you wish to know extra concerning the construct course of, simply kind swift construct --help and you may see your accessible choices for the construct command.

Yet one more factor

You may generate Xcode initiatives with the Swift Bundle Supervisor.

swift package deal generate-xcodeproj

This was SPM in a nutshell. Really we now have coreverd extra than simply the fundamentals, we deep-dived just a little into the Swift Bundle Supervisor, now you have to be accustomed to targets, merchandise and a lot of the accessible instructions, however there's all the time extra to study. So if you wish to know much more about this superb instrument, you need to test the Swift evolution dashboard for more information. Get pleasure from. 😉