Marco Eidinger
Swifty Tech by Marco Eidinger

Swifty Tech by Marco Eidinger

Use Swift Package Manager in your own Swift Package

Use Swift Package Manager in your own Swift Package

Programmatically access Swift package information

Marco Eidinger's photo
Marco Eidinger
Β·Mar 2, 2021Β·

5 min read

Subscribe to my newsletter and never miss my upcoming articles

As a Swift developer, you are probably aware of Apple's Swift Package Manager (SPM) as a command-line interface to create and work with Swift packages πŸ“¦.

But did you know that you can also use Swift Package Manager as a package dependency in your own Swift Package?

Yes, you can 😊 because SPM is also a package that exposes the library SwiftPM under the same product name. The community generally refers to it as libSwiftPM and I will continue to use that term in this blog post.

For example, it is possible to create an executable Swift package in which you can programmatically access manifest information from other Swift packages on your local machine and print that information in your terminal.

The GitHub repository of Swift Package Manager contains exactly such example: package-info

However, the package dependency to libSwiftPM is declared as a local, relative package. As we want to use libSwiftPM as a remote package dependency let's re-build the example.

First, we create a folder and name it swift-package-info. Then we use Swift Package Manager to create our executable package.

swift package init --type executable

Now let's add Swift Package Manager as a dependency to our package. There is a caveat for Swift 5.3 as libSwiftPM does not have a version tagged for 5.3 (status: March 2021)

Thankfully there is a community fork that has a version tagged and otherwise no modifications.

.package(name: "SwiftPM", url: "https://github.com/SDGGiesbrecht/swift-package-manager.git", .exact("0.50302.0")),

The complete manifest of our package


// swift-tools-version:5.3
// The swift-tools-version declares the minimum version of Swift required to build this package.
import PackageDescription

let package = Package(
    name: "swift-package-info",
    dependencies: [
        // Dependencies declare other packages that this package depends on.
        .package(name: "SwiftPM", url: "https://github.com/SDGGiesbrecht/swift-package-manager.git", .exact("0.50302.0")),
    ],
    targets: [
        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
        // Targets can depend on other targets in this package, and on products in packages this package depends on.
        .target(
            name: "swift-package-info",
            dependencies: ["SwiftPM"]),
        .testTarget(
            name: "swift-package-infoTests",
            dependencies: ["swift-package-info"]),
    ]
)

Now we can make use of modules in libSwiftPM to access several levels of information. In this blog post I'll focus on the manifest itself.

The ManifestLoader of module PackageLoading is a utility class for reading the manifest data and produce a properly formed PackageModel.Manifest object. Hence, we import the necessary module in our main.swift file

import PackageLoading

The API requires knowing where the Swift compiler is. The following code snippet(s) are straight from the original example and some are slightly simplified.

// PREREQUISITES
// ============
// We will need to know where the Swift compiler is.
let swiftCompiler: AbsolutePath = {
    let string: String
    #if os(macOS)
    string = try! Process.checkNonZeroExit(args: "xcrun", "--sdk", "macosx", "-f", "swiftc").spm_chomp()
    #else
    string = try! Process.checkNonZeroExit(args: "which", "swiftc").spm_chomp()
    #endif
    return AbsolutePath(string)
}()

For sake of simplification let's assume that our executable Swift Package will run in a directory in which a root package is available.

// We need a package to work with.
// This assumes there is one in the current working directory:
let packagePath = localFileSystem.currentWorkingDirectory!

With the path to the package in question as well as the Swift compiler we can finally load the manifest.

let diagnostics = DiagnosticsEngine()
let manifest = try ManifestLoader.loadManifest(packagePath: packagePath, swiftCompiler: swiftCompiler, packageKind: .root)

Now we can programmatically access information like products or targets.

// Manifest
let products = manifest.products.map({ $0.name }).joined(separator: ", ")
print("Products:", products)
let targets = manifest.targets.map({ $0.name }).joined(separator: ", ")
print("Targets:", targets)

The full source code, including other APIs, is available here.

Did you find this article valuable?

Support Marco Eidinger by becoming a sponsor. Any amount is appreciated!

See recent sponsors |Β Learn more about Hashnode Sponsors
Β 
Share this