Stop writing static files in ~/.carton/static

Instead, write them under plugin work directory

Author: kateinoigakukun

Plugins/CartonTest/Plugin.swift

@@ -103,6 +103,7 @@ struct CartonTestPlugin: CommandPlugin {
         "test",
         "--prebuilt-test-bundle-path", testProductArtifactPath,
         "--environment", options.environment.rawValue,
+        "--plugin-work-directory", context.pluginWorkDirectory.string
       ]
       + resourcesPaths.flatMap {
         ["--resources", $0.string]

Sources/CartonCLI/Commands/Bundle.swift

@@ -18,11 +18,6 @@ import CartonKit
 import Foundation
 import WasmTransformer
 
-private let dependency = Entrypoint(
-  fileName: "bundle.js",
-  sha256: bundleEntrypointSHA256
-)
-
 enum WasmOptimizations: String, CaseIterable, ExpressibleByArgument {
   case size, none
 }
@@ -78,8 +73,6 @@ struct Bundle: AsyncParsableCommand {
   func run() async throws {
     let terminal = InteractiveWriter.stderr
 
-    try dependency.check(on: localFileSystem, terminal)
-
     var mainWasmPath = try AbsolutePath(
       validating: mainWasmPath, relativeTo: localFileSystem.currentWorkingDirectory!)
     let buildDirectory = mainWasmPath.parentDirectory
@@ -175,9 +168,8 @@ struct Bundle: AsyncParsableCommand {
     try localFileSystem.move(from: wasmOutputFilePath, to: mainModulePath)
 
     // Copy the bundle entrypoint, point to the binary, and give it a cachebuster name.
-    let (_, _, entrypointPath) = try dependency.paths(on: localFileSystem)
-    let entrypoint = try ByteString(
-      encodingAsUTF8: localFileSystem.readFileContents(entrypointPath)
+    let entrypoint = ByteString(
+      encodingAsUTF8: StaticResource.bundle
         .description
         .replacingOccurrences(
           of: "REPLACE_THIS_WITH_THE_MAIN_WEBASSEMBLY_MODULE",

Sources/CartonCLI/Commands/Dev.swift

@@ -18,7 +18,7 @@ import CartonKit
 import Foundation
 
 struct Dev: AsyncParsableCommand {
-  static let entrypoint = Entrypoint(fileName: "dev.js", sha256: devEntrypointSHA256)
+  static let entrypoint = Entrypoint(fileName: "dev.js", content: StaticResource.dev)
 
   @Option(help: "Specify name of an executable product in development.")
   var product: String?
@@ -93,8 +93,6 @@ struct Dev: AsyncParsableCommand {
   func run() async throws {
     let terminal = InteractiveWriter.stdout
 
-    try Self.entrypoint.check(on: localFileSystem, terminal)
-
     let paths = try watchPaths.map {
       try AbsolutePath(validating: $0, relativeTo: localFileSystem.currentWorkingDirectory!)
     }

Sources/CartonCLI/Commands/Test.swift

@@ -86,6 +86,11 @@ struct Test: AsyncParsableCommand {
   )
   var resources: [String] = []
 
+  @Option(name: .long, help: ArgumentHelp(
+    "Internal: Path to writable directory", visibility: .private
+  ))
+  var pluginWorkDirectory: String = "./"
+
   func validate() throws {
     if headless && environment != .browser {
       throw TestError(
@@ -96,8 +101,9 @@ struct Test: AsyncParsableCommand {
   func run() async throws {
     let terminal = InteractiveWriter.stdout
     let bundlePath: AbsolutePath
+    let cwd = localFileSystem.currentWorkingDirectory!
     bundlePath = try AbsolutePath(
-      validating: prebuiltTestBundlePath, relativeTo: localFileSystem.currentWorkingDirectory!)
+      validating: prebuiltTestBundlePath, relativeTo: cwd)
     guard localFileSystem.exists(bundlePath, followSymlink: true) else {
       terminal.write(
         "No prebuilt binary found at \(bundlePath)\n",
@@ -125,6 +131,7 @@ struct Test: AsyncParsableCommand {
       ).run()
     case .node:
       try await NodeTestRunner(
+        pluginWorkDirectory: AbsolutePath(validating: pluginWorkDirectory, relativeTo: cwd),
         testFilePath: bundlePath,
         listTestCases: list,
         testCases: testCases,

Sources/CartonCLI/Commands/TestRunners/BrowserTestRunner.swift

@@ -24,7 +24,7 @@ import WebDriverClient
 #endif
 
 private enum Constants {
-  static let entrypoint = Entrypoint(fileName: "test.js", sha256: testEntrypointSHA256)
+  static let entrypoint = Entrypoint(fileName: "test.js", content: StaticResource.test)
 }
 
 enum BrowserTestRunnerError: Error, CustomStringConvertible {
@@ -152,7 +152,6 @@ struct BrowserTestRunner: TestRunner {
   }
 
   func run() async throws {
-    try Constants.entrypoint.check(on: localFileSystem, terminal)
     let server = try await Server(
       .init(
         builder: nil,

Sources/CartonCLI/Commands/TestRunners/NodeTestRunner.swift

@@ -17,11 +17,12 @@ import CartonKit
 import Foundation
 
 private enum Constants {
-  static let entrypoint = Entrypoint(fileName: "testNode.js", sha256: testNodeEntrypointSHA256)
+  static let entrypoint = Entrypoint(fileName: "testNode.js", content: StaticResource.testNode)
 }
 
 /// Test runner for Node.js.
 struct NodeTestRunner: TestRunner {
+  let pluginWorkDirectory: AbsolutePath
   let testFilePath: AbsolutePath
   let listTestCases: Bool
   let testCases: [String]
@@ -30,12 +31,13 @@ struct NodeTestRunner: TestRunner {
   func run() async throws {
     terminal.write("\nRunning the test bundle with Node.js:\n", inColor: .yellow)
 
-    try Constants.entrypoint.check(on: localFileSystem, terminal)
-    let (_, _, entrypointPath) = try Constants.entrypoint.paths(on: localFileSystem)
+    let entrypointPath = try Constants.entrypoint.write(
+      at: pluginWorkDirectory, fileSystem: localFileSystem
+    )
 
     // Allow Node.js to resolve modules from resource directories by making them relative to the entrypoint path.
     let buildDirectory = testFilePath.parentDirectory
-    let staticDirectory = entrypointPath.parentDirectory
+    let staticDirectory = pluginWorkDirectory
 
     // Clean up existing symlinks before creating new ones.
     for existingSymlink in try localFileSystem.resourcesDirectoryNames(relativeTo: staticDirectory)

Sources/CartonKit/Model/Entrypoint.swift

@@ -15,62 +15,18 @@
 import CartonHelpers
 import Foundation
 
-private struct StringError: Equatable, Codable, CustomStringConvertible, Error {
-  let description: String
-  init(_ description: String) {
-    self.description = description
-  }
-}
-
-extension StringError: CustomNSError {
-  var errorUserInfo: [String: Any] {
-    return [NSLocalizedDescriptionKey: self.description]
-  }
-}
-
 public struct Entrypoint {
   let fileName: String
-  let sha256: ByteString
+  let content: ByteString
 
-  public init(fileName: String, sha256: ByteString) {
+  public init(fileName: String, content: Data) {
     self.fileName = fileName
-    self.sha256 = sha256
+    self.content = ByteString(content)
   }
 
-  public func paths(
-    on fileSystem: FileSystem
-      // swiftlint:disable:next large_tuple
-  ) throws -> (cartonDir: AbsolutePath, staticDir: AbsolutePath, filePath: AbsolutePath) {
-    let cartonDir = try fileSystem.homeDirectory.appending(component: ".carton")
-    let staticDir = cartonDir.appending(component: "static")
-    return (cartonDir, staticDir, staticDir.appending(component: fileName))
-  }
-
-  public func check(on fileSystem: FileSystem, _ terminal: InteractiveWriter) throws {
-    let (cartonDir, staticDir, filePath) = try paths(on: fileSystem)
-
-    // If hash check fails, download the `static.zip` archive and unpack it
-    if try !fileSystem.exists(filePath, followSymlink: true)
-      || SHA256().hash(
-        fileSystem.readFileContents(filePath)
-      ) != sha256
-    {
-      terminal.logLookup("Directory doesn't exist or contains outdated polyfills: ", staticDir)
-      let archiveFile = cartonDir.appending(component: "static.zip")
-      try fileSystem.removeFileTree(staticDir)
-      try fileSystem.removeFileTree(archiveFile)
-
-      let staticArchiveBytes = Data(base64Encoded: staticArchiveContents)!
-      try fileSystem.createDirectory(cartonDir, recursive: true)
-      try fileSystem.writeFileContents(archiveFile, bytes: ByteString(staticArchiveBytes))
-      terminal.logLookup("Unpacking the archive: ", archiveFile)
-
-      try fileSystem.createDirectory(staticDir, recursive: false)
-      let result = try Process.popen(
-        args: "unzip", archiveFile.pathString, "-d", staticDir.pathString)
-      guard result.exitStatus == .terminated(code: 0) else {
-        throw try StringError(result.utf8stderrOutput())
-      }
-    }
+  public func write(at directory: AbsolutePath, fileSystem: FileSystem) throws -> AbsolutePath {
+    let path = directory.appending(component: fileName)
+    try fileSystem.writeFileContents(path, bytes: content)
+    return path
   }
 }

Sources/CartonKit/Server/StaticArchive.swift

@@ -39,13 +39,14 @@ struct HashArchive: AsyncParsableCommand {
     let terminal = InteractiveWriter.stdout
     let cwd = localFileSystem.currentWorkingDirectory!
     let staticPath = try AbsolutePath(validating: "static", relativeTo: cwd)
-    let dotFilesStaticPath = try localFileSystem.homeDirectory.appending(
-      components: ".carton",
-      "static"
-    )
 
-    try localFileSystem.createDirectory(dotFilesStaticPath, recursive: true)
-    var hashes: [(String, String)] = []
+    var fileContent = """
+    import Foundation
+
+    public enum StaticResource {
+
+    """
+
     for entrypoint in ["dev", "bundle", "test", "testNode"] {
       let tsFilename = "\(entrypoint).ts"
       let filename = "\(entrypoint).js"
@@ -70,52 +71,29 @@ struct HashArchive: AsyncParsableCommand {
       }
       try Foundation.Process.run(npx.asURL, arguments: arguments).waitUntilExit()
       let entrypointPath = try AbsolutePath(validating: filename, relativeTo: staticPath)
-      let dotFilesEntrypointPath = dotFilesStaticPath.appending(component: filename)
-      try localFileSystem.removeFileTree(dotFilesEntrypointPath)
-      try localFileSystem.copy(from: entrypointPath, to: dotFilesEntrypointPath)
-
-      hashes.append(
-        (
-          entrypoint,
-          try SHA256().hash(localFileSystem.readFileContents(entrypointPath))
-            .hexadecimalRepresentation.uppercased()
-        ))
-    }
-
-    let archiveSources = try localFileSystem.getDirectoryContents(staticPath)
-      .map { try AbsolutePath(validating: $0, relativeTo: staticPath) }
-      .map(\.pathString)
 
-    try await Process.run(["zip", "-j", "static.zip"] + archiveSources, terminal)
-
-    let staticArchiveContents = try localFileSystem.readFileContents(
-      AbsolutePath(
-        validating: "static.zip",
-        relativeTo: localFileSystem.currentWorkingDirectory!
-      ))
-
-    // Base64 is not an efficient way, but too long byte array literal breaks type-checker
-    let hashesFileContent = """
-      import CartonHelpers
+      // Base64 is not an efficient way, but too long byte array literal breaks type-checker
+      let base64Content = try localFileSystem.readFileContents(entrypointPath).withData {
+        $0.base64EncodedString()
+      }
+      fileContent += """
+        public static let \(entrypoint): Data = Data(base64Encoded: \"\(base64Content)\")!
 
-      \(hashes.map {
       """
-      public let \($0)EntrypointSHA256 = ByteString([
-      \(arrayString(from: $1))
-      ])
-      """
-      }.joined(separator: "\n\n"))
+    }
 
-      public let staticArchiveContents = "\(staticArchiveContents.withData { $0.base64EncodedString() })"
-      """
+    fileContent += """
+
+    }
+    """
 
     try localFileSystem.writeFileContents(
       AbsolutePath(
         cwd,
         RelativePath(validating: "Sources").appending(
           components: "CartonKit", "Server", "StaticArchive.swift")
       ),
-      bytes: ByteString(encodingAsUTF8: hashesFileContent)
+      bytes: ByteString(encodingAsUTF8: fileContent)
     )
   }
 }