Model lipo invocations with a modeled command structure with a test

Author: cmcgee1024

Sources/SwiftlyCore/Commands.swift

@@ -48,7 +48,7 @@ extension SystemCommand {
             self.read(path: path, keys: keys)
         }
 
-        public struct ReadCommand: Output {
+        public struct ReadCommand {
             var dscl: DsclCommand
             var path: FilePath?
             var keys: [String]
@@ -76,7 +76,7 @@ extension SystemCommand {
     }
 }
 
-extension SystemCommand.DsclCommand.ReadCommand {
+extension SystemCommand.DsclCommand.ReadCommand: Output {
     public func properties(_ p: Platform) async throws -> [(key: String, value: String)] {
         let output = try await self.output(p)
         guard let output else { return [] }
@@ -90,3 +90,79 @@ extension SystemCommand.DsclCommand.ReadCommand {
         return props
     }
 }
+
+extension SystemCommand {
+    public static func lipo(executable: Executable = LipoCommand.defaultExecutable, inputFiles: FilePath...) -> LipoCommand {
+        Self.lipo(executable: executable, inputFiles: inputFiles)
+    }
+
+    public static func lipo(executable: Executable = LipoCommand.defaultExecutable, inputFiles: [FilePath]) -> LipoCommand {
+        LipoCommand(executable: executable, inputFiles: inputFiles)
+    }
+
+    public struct LipoCommand {
+        public static var defaultExecutable: Executable { .name("lipo") }
+
+        var executable: Executable
+        var inputFiles: [FilePath]
+
+        public init(executable: Executable, inputFiles: [FilePath]) {
+            self.executable = executable
+            self.inputFiles = inputFiles
+        }
+
+        func config() -> Configuration {
+            var args: [String] = []
+
+            args += self.inputFiles.map(\.string)
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+
+        public func create(_ options: CreateCommand.Option...) -> CreateCommand {
+            CreateCommand(self, options)
+        }
+
+        public struct CreateCommand {
+            var lipo: LipoCommand
+
+            var options: [Option]
+
+            init(_ lipo: LipoCommand, _ options: [Option]) {
+                self.lipo = lipo
+                self.options = options
+            }
+
+            public enum Option {
+                case output(FilePath)
+
+                func args() -> [String] {
+                    switch self {
+                    case let .output(output):
+                        return ["-output", output.string]
+                    }
+                }
+            }
+
+            public func config() -> Configuration {
+                var c = self.lipo.config()
+
+                var args = c.arguments.storage.map(\.description) + ["-create"]
+
+                for opt in self.options {
+                    args += opt.args()
+                }
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+    }
+}
+
+extension SystemCommand.LipoCommand.CreateCommand: Runnable {}

Sources/SwiftlyCore/ModeledCommandLine.swift

@@ -126,7 +126,7 @@ public protocol Runnable {
 }
 
 extension Runnable {
-    public func run(_ p: Platform, quiet: Bool) async throws {
+    public func run(_ p: Platform, quiet: Bool = false) async throws {
         let c = self.config()
         let executable = switch c.executable.storage {
         case let .executable(name):

Tests/SwiftlyTests/CommandLineTests.swift

@@ -28,4 +28,11 @@ public struct CommandLineTests {
         #expect(properties.count == 1) // Only one shell for the current user
         #expect(properties[0].key == "UserShell") // The one property key should be the one that is requested
     }
+
+    @Test func testLipo() {
+        var config = sys.lipo(inputFiles: FilePath("swiftly1"), FilePath("swiftly2")).create(.output(FilePath("swiftly-universal"))).config()
+
+        #expect(config.executable == .name("lipo"))
+        #expect(config.arguments.storage.map(\.description) == ["swiftly1", "swiftly2", "-create", "-output", "swiftly-universal"])
+    }
 }

Tools/build-swiftly-release/BuildSwiftlyRelease.swift

@@ -1,6 +1,7 @@
 import ArgumentParser
 import Foundation
 import SwiftlyCore
+import SystemPackage
 
 #if os(macOS)
 import MacOSPlatform
@@ -14,6 +15,9 @@ let currentPlatform = MacOS()
 let currentPlatform = Linux()
 #endif
 
+typealias fs = FileSystem
+typealias sys = SystemCommand
+
 public struct SwiftPlatform: Codable {
     public var name: String?
     public var checksum: String?
@@ -392,7 +396,6 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
 
         try await self.checkGitRepoStatus(git)
 
-        let lipo = try await self.assertTool("lipo", message: "In order to make a universal binary there needs to be the `lipo` tool that is installed on macOS.")
         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.")
 
@@ -405,10 +408,13 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             try runProgram(strip, ".build/\(arch)-apple-macosx/release/swiftly")
         }
 
-        let swiftlyBinDir = FileManager.default.currentDirectoryPath + "/.build/release/.swiftly/bin"
-        try? FileManager.default.createDirectory(atPath: swiftlyBinDir, withIntermediateDirectories: true)
+        let swiftlyBinDir = fs.cwd / ".build/release/.swiftly/bin"
+        try? await fs.mkdir(.parents, atPath: swiftlyBinDir)
 
-        try runProgram(lipo, ".build/x86_64-apple-macosx/release/swiftly", ".build/arm64-apple-macosx/release/swiftly", "-create", "-o", "\(swiftlyBinDir)/swiftly")
+        try await sys.lipo(
+            inputFiles: FilePath(".build/x86_64-apple-macosx/release/swiftly"), FilePath(".build/arm64-apple-macosx/release/swiftly"))
+            .create(.output(swiftlyBinDir / "swiftly"))
+            .run(currentPlatform)
 
         let swiftlyLicenseDir = FileManager.default.currentDirectoryPath + "/.build/release/.swiftly/license"
         try? FileManager.default.createDirectory(atPath: swiftlyLicenseDir, withIntermediateDirectories: true)
@@ -423,7 +429,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             try runProgram(
                 pkgbuild,
                 "--root",
-                swiftlyBinDir + "/..",
+                "\(swiftlyBinDir.removingLastComponent)",
                 "--install-location",
                 ".swiftly",
                 "--version",
@@ -438,7 +444,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             try runProgram(
                 pkgbuild,
                 "--root",
-                swiftlyBinDir + "/..",
+                "\(swiftlyBinDir.removingLastComponent)",
                 "--install-location",
                 ".swiftly",
                 "--version",
@@ -479,7 +485,11 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
 
             let testArchive = releaseDir.appendingPathComponent("test-swiftly-macos.tar.gz")
 
-            try runProgram(lipo, ".build/x86_64-apple-macosx/debug/test-swiftly", ".build/arm64-apple-macosx/debug/test-swiftly", "-create", "-o", "\(swiftlyBinDir)/swiftly")
+            try await sys.lipo(
+                inputFiles: FilePath(".build/x86_64-apple-macosx/debug/test-swiftly"), FilePath(".build/arm64-apple-macosx/debug/test-swiftly"))
+                .create(.output(swiftlyBinDir / "swiftly"))
+                .run(currentPlatform)
+
             try runProgram(tar, "--directory=.build/x86_64-apple-macosx/debug", "-czf", testArchive.path, "test-swiftly")
 
             print(testArchive.path)