Model make, strip, and sha256sum

Author: cmcgee1024

Sources/SwiftlyCore/Commands.swift

@@ -946,3 +946,130 @@ extension SystemCommand.SwiftCommand.PackageCommand.InitCommand: Runnable {}
 extension SystemCommand.SwiftCommand.SdkCommand.InstallCommand: Runnable {}
 extension SystemCommand.SwiftCommand.SdkCommand.RemoveCommand: Runnable {}
 extension SystemCommand.SwiftCommand.BuildCommand: Runnable {}
+
+extension SystemCommand {
+    public static func make(executable: Executable = MakeCommand.defaultExecutable) -> MakeCommand {
+        MakeCommand(executable: executable)
+    }
+
+    public struct MakeCommand {
+        public static var defaultExecutable: Executable { .name("make") }
+
+        public var executable: Executable
+
+        public init(executable: Executable) {
+            self.executable = executable
+        }
+
+        public func config() -> Configuration {
+            var args: [String] = []
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+
+        public func install() -> InstallCommand {
+            InstallCommand(self)
+        }
+
+        public struct InstallCommand {
+            var make: MakeCommand
+
+            init(_ make: MakeCommand) {
+                self.make = make
+            }
+
+            public func config() -> Configuration {
+                var c = self.make.config()
+
+                var args = c.arguments.storage.map(\.description)
+
+                args.append("install")
+
+                c.arguments = .init(args)
+
+                return c
+            }
+        }
+    }
+}
+
+extension SystemCommand.MakeCommand: Runnable {}
+extension SystemCommand.MakeCommand.InstallCommand: Runnable {}
+
+extension SystemCommand {
+    public static func strip(executable: Executable = StripCommand.defaultExecutable, names: FilePath...) -> StripCommand {
+        self.strip(executable: executable, names: names)
+    }
+
+    public static func strip(executable: Executable = StripCommand.defaultExecutable, names: [FilePath]) -> StripCommand {
+        StripCommand(executable: executable, names: names)
+    }
+
+    public struct StripCommand {
+        public static var defaultExecutable: Executable { .name("strip") }
+
+        public var executable: Executable
+
+        public var names: [FilePath]
+
+        public init(executable: Executable, names: [FilePath]) {
+            self.executable = executable
+            self.names = names
+        }
+
+        public func config() -> Configuration {
+            var args: [String] = []
+
+            args.append(contentsOf: self.names.map(\.string))
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+    }
+}
+
+extension SystemCommand.StripCommand: Runnable {}
+
+extension SystemCommand {
+    public static func sha256sum(executable: Executable = Sha256SumCommand.defaultExecutable, files: FilePath...) -> Sha256SumCommand {
+        self.sha256sum(executable: executable, files: files)
+    }
+
+    public static func sha256sum(executable: Executable, files: [FilePath]) -> Sha256SumCommand {
+        Sha256SumCommand(executable: executable, files: files)
+    }
+
+    public struct Sha256SumCommand {
+        public static var defaultExecutable: Executable { .name("sha256sum") }
+
+        public var executable: Executable
+
+        public var files: [FilePath]
+
+        public init(executable: Executable, files: [FilePath]) {
+            self.executable = executable
+            self.files = files
+        }
+
+        public func config() -> Configuration {
+            var args: [String] = []
+
+            args.append(contentsOf: self.files.map(\.string))
+
+            return Configuration(
+                executable: self.executable,
+                arguments: Arguments(args),
+                environment: .inherit
+            )
+        }
+    }
+}
+
+extension SystemCommand.Sha256SumCommand: Output {}

Sources/SwiftlyCore/ModeledCommandLine.swift

@@ -154,7 +154,7 @@ public protocol Runnable {
 }
 
 extension Runnable {
-    public func run(_ p: Platform, quiet: Bool = false) async throws {
+    public func run(_ p: Platform, env: [String: String] = ProcessInfo.processInfo.environment, quiet: Bool = false) async throws {
         let c = self.config()
         let executable = switch c.executable.storage {
         case let .executable(name):
@@ -163,16 +163,19 @@ extension Runnable {
             p.string
         }
         let args = c.arguments.storage.map(\.description)
-        var env: [String: String] = ProcessInfo.processInfo.environment
+
+        var newEnv: [String: String] = env
+
         switch c.environment.config {
         case let .inherit(newValue):
             for (key, value) in newValue {
-                env[key] = value
+                newEnv[key] = value
             }
         case let .custom(newValue):
-            env = newValue
+            newEnv = newValue
         }
-        try await p.runProgram([executable] + args, quiet: quiet, env: env)
+
+        try await p.runProgram([executable] + args, quiet: quiet, env: newEnv)
     }
 }
 

Tests/SwiftlyTests/CommandLineTests.swift

@@ -194,4 +194,19 @@ public struct CommandLineTests {
         try await sys.swift().package()._init(.packagePath(tmp), .type("executable")).run(Swiftly.currentPlatform)
         try await sys.swift().build(.packagePath(tmp), .configuration("release"))
     }
+
+    @Test func testMake() async throws {
+        var config = sys.make().install().config()
+        #expect(String(describing: config) == "make install")
+    }
+
+    @Test func testStrip() async throws {
+        var config = sys.strip(names: FilePath("foo")).config()
+        #expect(String(describing: config) == "strip foo")
+    }
+
+    @Test func testSha256Sum() async throws {
+        var config = sys.sha256sum(files: FilePath("abcde")).config()
+        #expect(String(describing: config) == "sha256sum abcde")
+    }
 }

Tools/build-swiftly-release/BuildSwiftlyRelease.swift

@@ -213,7 +213,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         return nil
     }
 
-    func checkGitRepoStatus(_: String) async throws {
+    func checkGitRepoStatus() async throws {
         guard !self.skip else {
             return
         }
@@ -241,12 +241,8 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
     func buildLinuxRelease() async throws {
         // TODO: turn these into checks that the system meets the criteria for being capable of using the toolchain + checking for packages, not tools
         let curl = try await self.assertTool("curl", message: "Please install curl with `yum install curl`")
-        let make = try await self.assertTool("make", message: "Please install make with `yum install make`")
-        let git = try await self.assertTool("git", message: "Please install git with `yum install git`")
-        let strip = try await self.assertTool("strip", message: "Please install strip with `yum install binutils`")
-        let sha256sum = try await self.assertTool("sha256sum", message: "Please install sha256sum with `yum install coreutils`")
 
-        try await self.checkGitRepoStatus(git)
+        try await self.checkGitRepoStatus()
 
         // Start with a fresh SwiftPM package
         try await sys.swift().package().reset().run(currentPlatform)
@@ -264,7 +260,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
 
         try? FileManager.default.removeItem(atPath: libArchivePath)
         try runProgram(curl, "-L", "-o", "\(buildCheckoutsDir + "/libarchive-\(libArchiveVersion).tar.gz")", "--remote-name", "--location", "https://github.com/libarchive/libarchive/releases/download/v\(libArchiveVersion)/libarchive-\(libArchiveVersion).tar.gz")
-        let libArchiveTarShaActual = try await runProgramOutput(sha256sum, "\(buildCheckoutsDir)/libarchive-\(libArchiveVersion).tar.gz")
+        let libArchiveTarShaActual = try await sys.sha256sum(files: FilePath("\(buildCheckoutsDir)/libarchive-\(libArchiveVersion).tar.gz")).output(currentPlatform)
         guard let libArchiveTarShaActual, libArchiveTarShaActual.starts(with: libArchiveTarSha) else {
             let shaActual = libArchiveTarShaActual ?? "none"
             throw Error(message: "The libarchive tar.gz file sha256sum is \(shaActual), but expected \(libArchiveTarSha)")
@@ -330,9 +326,9 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
             env: customEnv
         )
 
-        try runProgramEnv(make, env: customEnv)
+        try await sys.make().run(currentPlatform, env: customEnv)
 
-        try runProgram(make, "install")
+        try await sys.make().install().run(currentPlatform)
 
         FileManager.default.changeCurrentDirectoryPath(cwd)
 
@@ -341,7 +337,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         let releaseDir = cwd + "/.build/release"
 
         // Strip the symbols from the binary to decrease its size
-        try runProgram(strip, releaseDir + "/swiftly")
+        try await sys.strip(names: FilePath(releaseDir) / "swiftly").run(currentPlatform)
 
         try await self.collectLicenses(releaseDir)
 
@@ -374,18 +370,13 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
     }
 
     func buildMacOSRelease(cert: String?, identifier: String) async throws {
-        // Check system requirements
-        let git = try await self.assertTool("git", message: "Please install git with either `xcode-select --install` or `brew install git`")
-
-        try await self.checkGitRepoStatus(git)
-
-        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.")
+        try await self.checkGitRepoStatus()
 
         try await sys.swift().package().clean().run(currentPlatform)
 
         for arch in ["x86_64", "arm64"] {
             try await sys.swift().build(.product("swiftly"), .configuration("release"), .arch("\(arch)")).run(currentPlatform)
-            try runProgram(strip, ".build/\(arch)-apple-macosx/release/swiftly")
+            try await sys.strip(names: FilePath(".build") / "\(arch)-apple-macosx/release/swiftly").run(currentPlatform)
         }
 
         let swiftlyBinDir = fs.cwd / ".build/release/.swiftly/bin"
@@ -450,7 +441,7 @@ struct BuildSwiftlyRelease: AsyncParsableCommand {
         if self.test {
             for arch in ["x86_64", "arm64"] {
                 try await sys.swift().build(.product("test-swiftly"), .configuration("debug"), .arch("\(arch)")).run(currentPlatform)
-                try runProgram(strip, ".build/\(arch)-apple-macosx/release/swiftly")
+                try await sys.strip(names: FilePath(".build") / "\(arch)-apple-macosx/release/swiftly").run(currentPlatform)
             }
 
             let testArchive = releaseDir.appendingPathComponent("test-swiftly-macos.tar.gz")