Model the pkgbuild command

cmcgee1024 · cmcgee1024 · commit 8dc6b7eb37ab · 2025-04-25T10:49:31.000-04:00
Model the pkgbuild command with the usual structure used for other
commands.

Provide a custom string convertible implementation for configuration
so that the configuration can be easily converted into a string for
logging and comparison purposes.

Create a runEcho() implementation for the build swiftly release
script so that commands can output their command-line to the log
for reproducibility.
diff --git a/Sources/SwiftlyCore/Commands.swift b/Sources/SwiftlyCore/Commands.swift
@@ -91,6 +91,8 @@ extension SystemCommand.DsclCommand.ReadCommand: Output {
     }
 }
 
+// Create or operate on universal files
+// See lipo(1) for details
 extension SystemCommand {
     public static func lipo(executable: Executable = LipoCommand.defaultExecutable, inputFiles: FilePath...) -> LipoCommand {
         Self.lipo(executable: executable, inputFiles: inputFiles)
@@ -106,7 +108,7 @@ extension SystemCommand {
         var executable: Executable
         var inputFiles: [FilePath]
 
-        public init(executable: Executable, inputFiles: [FilePath]) {
+        internal init(executable: Executable, inputFiles: [FilePath]) {
             self.executable = executable
             self.inputFiles = inputFiles
         }
@@ -150,3 +152,72 @@ extension SystemCommand {
 }
 
 extension SystemCommand.LipoCommand.CreateCommand: Runnable {}
+
+// Build a macOS Installer component package from on-disk files
+// See pkgbuild(1) for more details
+extension SystemCommand {
+    public static func pkgbuild(executable: Executable = PkgbuildCommand.defaultExecutable, _ options: PkgbuildCommand.Option..., root: FilePath, packageOutputPath: FilePath) -> PkgbuildCommand {
+        Self.pkgbuild(executable: executable, options: options, root: root, packageOutputPath: packageOutputPath)
+    }
+
+    public static func pkgbuild(executable: Executable = PkgbuildCommand.defaultExecutable, options: [PkgbuildCommand.Option], root: FilePath, packageOutputPath: FilePath) -> PkgbuildCommand {
+        PkgbuildCommand(executable: executable, options, root: root, packageOutputPath: packageOutputPath)
+    }
+
+    public struct PkgbuildCommand {
+        public static var defaultExecutable: Executable { .name("pkgbuild") }
+
+        var executable: Executable
+
+        var options: [Option]
+
+        var root: FilePath
+        var packageOutputPath: FilePath
+
+        internal init(executable: Executable, _ options: [Option], root: FilePath, packageOutputPath: FilePath) {
+            self.executable = executable
+            self.options = options
+            self.root = root
+            self.packageOutputPath = packageOutputPath
+        }
+
+        public enum Option {
+            case installLocation(FilePath)
+            case version(String)
+            case identifier(String)
+            case sign(String)
+
+            func args() -> [String] {
+                switch self {
+                case let .installLocation(installLocation):
+                    return ["--install-location", installLocation.string]
+                case let .version(version):
+                    return ["--version", version]
+                case let .identifier(identifier):
+                    return ["--identifier", identifier]
+                case let .sign(identityName):
+                    return ["--sign", identityName]
+                }
+            }
+        }
+
+        public func config() -> Configuration {
+            var args: [String] = []
+
+            for option in self.options {
+                args += option.args()
+            }
+
+            args += ["--root", "\(self.root)"]
+            args += ["\(self.packageOutputPath)"]
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+    }
+}
+
+extension SystemCommand.PkgbuildCommand: Runnable {}
diff --git a/Sources/SwiftlyCore/ModeledCommandLine.swift b/Sources/SwiftlyCore/ModeledCommandLine.swift
@@ -121,6 +121,38 @@ public struct Arguments: Sendable, ExpressibleByArrayLiteral, Hashable {
     }
 }
 
+// Provide string representations of Configuration
+extension Executable: CustomStringConvertible {
+    public var description: String {
+        switch self.storage {
+        case let .executable(name):
+            name
+        case let .path(path):
+            path.string
+        }
+    }
+}
+
+extension Arguments: CustomStringConvertible {
+    public var description: String {
+        let normalized: [String] = self.storage.map(\.description).map {
+            if $0.contains(" ") {
+                return "\"\($0)\""
+            } else {
+                return String($0)
+            }
+        }
+
+        return normalized.joined(separator: " ")
+    }
+}
+
+extension Configuration: CustomStringConvertible {
+    public var description: String {
+        "\(self.executable) \(self.arguments)"
+    }
+}
+
 public protocol Runnable {
     func config() -> Configuration
 }
diff --git a/Tests/SwiftlyTests/CommandLineTests.swift b/Tests/SwiftlyTests/CommandLineTests.swift
@@ -39,4 +39,12 @@ public struct CommandLineTests {
         #expect(config.executable == .name("lipo"))
         #expect(config.arguments.storage.map(\.description) == ["swiftly", "-create", "-output", "swiftly-universal-with-one-arch"])
     }
+
+    @Test func testPkgbuild() {
+        var config = sys.pkgbuild(root: "mypath", packageOutputPath: "outputDir").config()
+        #expect(String(describing: config) == "pkgbuild --root mypath outputDir")
+
+        config = sys.pkgbuild(.version("1234"), root: "somepath", packageOutputPath: "output").config()
+        #expect(String(describing: config) == "pkgbuild --version 1234 --root somepath output")
+    }
 }
diff --git a/Tests/SwiftlyTests/SwiftlyTests.swift b/Tests/SwiftlyTests/SwiftlyTests.swift
@@ -940,22 +940,14 @@ public final actor MockToolchainDownloader: HTTPRequestExecutor {
 
         let pkg = tmp / "swiftly.pkg"
 
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/usr/bin/env")
-        task.arguments = [
-            "pkgbuild",
-            "--root",
-            "\(swiftlyDir)",
-            "--install-location",
-            ".swiftly",
-            "--version",
-            "\(self.latestSwiftlyVersion)",
-            "--identifier",
-            "org.swift.swiftly",
-            "\(pkg)",
-        ]
-        try task.run()
-        task.waitUntilExit()
+        try await sys.pkgbuild(
+            .installLocation("swiftly"),
+            .version("\(self.latestSwiftlyVersion)"),
+            .identifier("org.swift.swiftly"),
+            root: swiftlyDir,
+            packageOutputPath: pkg
+        )
+        .run(Swiftly.currentPlatform)
 
         let data = try Data(contentsOf: pkg)
         try await fs.remove(atPath: tmp)
@@ -993,24 +985,16 @@ public final actor MockToolchainDownloader: HTTPRequestExecutor {
         let data = try encoder.encode(pkgInfo)
         try data.write(to: toolchainDir.appending("Info.plist"))
 
-        let pkg = tmp.appending("toolchain.pkg")
+        let pkg = tmp / "toolchain.pkg"
 
-        let task = Process()
-        task.executableURL = URL(fileURLWithPath: "/usr/bin/env")
-        task.arguments = [
-            "pkgbuild",
-            "--root",
-            "\(toolchainDir)",
-            "--install-location",
-            "Library/Developer/Toolchains/\(toolchain.identifier).xctoolchain",
-            "--version",
-            "\(toolchain.name)",
-            "--identifier",
-            pkgInfo.CFBundleIdentifier,
-            "\(pkg)",
-        ]
-        try task.run()
-        task.waitUntilExit()
+        try await sys.pkgbuild(
+            .installLocation(FilePath("Library/Developer/Toolchains/\(toolchain.identifier).xctoolchain")),
+            .version("\(toolchain.name)"),
+            .identifier(pkgInfo.CFBundleIdentifier),
+            root: toolchainDir,
+            packageOutputPath: pkg
+        )
+        .run(Swiftly.currentPlatform)
 
         let pkgData = try Data(contentsOf: pkg)
         try await fs.remove(atPath: tmp)
diff --git a/Tools/build-swiftly-release/BuildSwiftlyRelease.swift b/Tools/build-swiftly-release/BuildSwiftlyRelease.swift
@@ -18,6 +18,17 @@ let currentPlatform = Linux()
 typealias fs = FileSystem
 typealias sys = SystemCommand
 
+extension Runnable {
+    // Runs the command while echoing the full command-line to stdout for logging and reproduction
+    func runEcho(_ platform: Platform, quiet: Bool = false) async throws {
+        let config = self.config()
+        // if !quiet { print("\(args.joined(separator: " "))") }
+        if !quiet { print("\(config)") }
+
+        try await self.run(platform)
+    }
+}
+
 public struct SwiftPlatform: Codable {
     public var name: String?
     public var checksum: String?
@@ -396,7 +407,6 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
 
         try await self.checkGitRepoStatus(git)
 
-        let pkgbuild = try await self.assertTool("pkgbuild", message: "In order to make pkg installers there needs to be the `pkgbuild` tool that is installed on macOS.")
         let strip = try await self.assertTool("strip", message: "In order to strip binaries there needs to be the `strip` tool that is installed on macOS.")
 
         let tar = try await self.assertTool("tar", message: "In order to produce archives there needs to be the `tar` tool that is installed on macOS.")
@@ -415,7 +425,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             inputFiles: ".build/x86_64-apple-macosx/release/swiftly", ".build/arm64-apple-macosx/release/swiftly"
         )
         .create(output: swiftlyBinDir / "swiftly")
-        .run(currentPlatform)
+        .runEcho(currentPlatform)
 
         let swiftlyLicenseDir = FileManager.default.currentDirectoryPath + "/.build/release/.swiftly/license"
         try? FileManager.default.createDirectory(atPath: swiftlyLicenseDir, withIntermediateDirectories: true)
@@ -427,33 +437,22 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         let pkgFile = releaseDir.appendingPathComponent("/swiftly-\(self.version).pkg")
 
         if let cert {
-            try runProgram(
-                pkgbuild,
-                "--root",
-                "\(swiftlyBinDir.parent)",
-                "--install-location",
-                ".swiftly",
-                "--version",
-                self.version,
-                "--identifier",
-                identifier,
-                "--sign",
-                cert,
-                ".build/release/swiftly-\(self.version).pkg"
-            )
+            try await sys.pkgbuild(
+                .installLocation(".swiftly"),
+                .version(self.version),
+                .identifier(identifier),
+                .sign(cert),
+                root: swiftlyBinDir.parent,
+                packageOutputPath: FilePath(".build/release/swiftly-\(self.version).pkg")
+            ).runEcho(currentPlatform)
         } else {
-            try runProgram(
-                pkgbuild,
-                "--root",
-                "\(swiftlyBinDir.parent)",
-                "--install-location",
-                ".swiftly",
-                "--version",
-                self.version,
-                "--identifier",
-                identifier,
-                ".build/release/swiftly-\(self.version).pkg"
-            )
+            try await sys.pkgbuild(
+                .installLocation(".swiftly"),
+                .version(self.version),
+                .identifier(identifier),
+                root: swiftlyBinDir.parent,
+                packageOutputPath: FilePath(".build/release/swiftly-\(self.version).pkg")
+            ).runEcho(currentPlatform)
         }
 
         // Re-configure the pkg to prefer installs into the current user's home directory with the help of productbuild.
@@ -490,7 +489,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
                 inputFiles: ".build/x86_64-apple-macosx/debug/test-swiftly", ".build/arm64-apple-macosx/debug/test-swiftly"
             )
             .create(output: swiftlyBinDir / "swiftly")
-            .run(currentPlatform)
+            .runEcho(currentPlatform)
 
             try runProgram(tar, "--directory=.build/x86_64-apple-macosx/debug", "-czf", testArchive.path, "test-swiftly")
 

Original file line number	Diff line number	Diff line change
`@@ -39,4 +39,12 @@ public struct CommandLineTests {`
`39`	`39`	`#expect(config.executable == .name("lipo"))`
`40`	`40`	`#expect(config.arguments.storage.map(\.description) == ["swiftly", "-create", "-output", "swiftly-universal-with-one-arch"])`
`41`	`41`	`}`
	`42`	`+`
	`43`	`+ @Test func testPkgbuild() {`
	`44`	`+ var config = sys.pkgbuild(root: "mypath", packageOutputPath: "outputDir").config()`
	`45`	`+ #expect(String(describing: config) == "pkgbuild --root mypath outputDir")`
	`46`	`+`
	`47`	`+ config = sys.pkgbuild(.version("1234"), root: "somepath", packageOutputPath: "output").config()`
	`48`	`+ #expect(String(describing: config) == "pkgbuild --version 1234 --root somepath output")`
	`49`	`+ }`
`42`	`50`	`}`