Make bootstrapping from NOTHING possible by having JavaKit include gradle wrapper

Author: ktoso

JavaKit/build.gradle

@@ -43,11 +43,35 @@ tasks.test {
   }
 }
 
+// Copy the gradle wrapper we're using into the resulting jar's resources.
+// We'll use it to bootstrap dependencies (and gradle!) if there is none yet.
+tasks.processResources {
+  from('gradlew') {
+    into 'gradle/'
+  }
+  from('gradlew.bat') {
+    into 'gradle/'
+  }
+  from('../gradle/wrapper/gradle-wrapper.jar') {
+    into 'gradle/wrapper/'
+  }
+  from('../gradle/wrapper/gradle-wrapper.properties') {
+    into 'gradle/wrapper/'
+  }
+}
+
+//task fatJar(type: Jar) {
+//    archiveBaseName = 'java-kit-fat-jar'
+//    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+//    from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } }
+//    with jar
+//}
+
 // Task necessary to bootstrap
 task printRuntimeClasspath {
     def runtimeClasspath = sourceSets.main.runtimeClasspath
     inputs.files(runtimeClasspath)
     doLast {
         println("CLASSPATH:${runtimeClasspath.asPath}")
     }
-}
+}

JavaKit/src/main/java/org/swift/javakit/dependencies/DependencyResolver.java

@@ -51,6 +51,7 @@ public class DependencyResolver {
     public static String resolveDependenciesToClasspath(String projectBaseDirectoryString, String[] dependencies) throws IOException {
         try {
             simpleLog("Fetch dependencies: " + Arrays.toString(dependencies));
+            simpleLog("Classpath: " + System.getProperty("java.class.path"));
             var projectBasePath = new File(projectBaseDirectoryString).toPath();
 
             File projectDir = Files.createTempDirectory("java-swift-dependencies").toFile();
@@ -118,7 +119,7 @@ private static String resolveDependenciesWithSubprocess(File gradleProjectDir) t
         stderrFile.deleteOnExit();
 
         try {
-            ProcessBuilder gradleBuilder = new ProcessBuilder("gradle", ":printRuntimeClasspath");
+            ProcessBuilder gradleBuilder = new ProcessBuilder("./gradlew", ":printRuntimeClasspath");
             gradleBuilder.directory(gradleProjectDir);
             gradleBuilder.redirectOutput(stdoutFile);
             gradleBuilder.redirectError(stderrFile);
@@ -172,7 +173,7 @@ public static boolean hasDependencyResolverDependenciesLoaded() {
      *
      * @return classpath which was resolved for the dependencies
      */
-    private static String resolveDependenciesUsingAPI(File projectDir, String[] dependencies) throws FileNotFoundException {
+    private static String resolveDependenciesUsingAPI(File projectDir, String[] dependencies) throws IOException {
         printBuildFiles(projectDir, dependencies);
 
         var connection = GradleConnector.newConnector()
@@ -196,7 +197,7 @@ private static String resolveDependenciesUsingAPI(File projectDir, String[] depe
 
             // remove output directories of the project we used for the dependency resolution
             var classpath = Arrays.stream(classpathString
-                    .split(":"))
+                            .split(":"))
                     .filter(s -> !s.startsWith(projectDir.getAbsolutePath()))
                     .collect(Collectors.joining(":"));
 
@@ -221,7 +222,8 @@ private static boolean hasDependencyResolverDependenciesLoaded(ClassLoader class
         }
     }
 
-    private static void printBuildFiles(File projectDir, String[] dependencies) throws FileNotFoundException {
+    private static void printBuildFiles(File projectDir, String[] dependencies) throws IOException {
+        // === build.gradle
         File buildFile = new File(projectDir, "build.gradle");
         try (PrintWriter writer = new PrintWriter(buildFile)) {
             writer.println("plugins { id 'java-library' }");
@@ -244,12 +246,48 @@ private static void printBuildFiles(File projectDir, String[] dependencies) thro
                     """);
         }
 
+        // === settings.gradle
         File settingsFile = new File(projectDir, "settings.gradle.kts");
         try (PrintWriter writer = new PrintWriter(settingsFile)) {
             writer.println("""
                     rootProject.name = "swift-java-resolve-temp-project"
                     """);
         }
+
+        // === gradle wrapper files, so we can even download gradle when necessary to bootstrap
+        File gradlew = new File(projectDir, "gradlew");
+        writeResourceToFile("/gradle/gradlew", gradlew);
+        gradlew.setExecutable(true);
+
+        File gradlewBat = new File(projectDir, "gradlew.bat");
+        writeResourceToFile("/gradle/gradlew.bat", gradlewBat);
+        gradlew.setExecutable(true);
+
+        File gradleDir = new File(projectDir, "gradle");
+        File gradleWrapperDir = new File(gradleDir, "wrapper");
+        gradleWrapperDir.mkdirs();
+
+        File gradleWrapperJar = new File(gradleWrapperDir, "gradle-wrapper.jar");
+        writeResourceToFile("/gradle/wrapper/gradle-wrapper.jar", gradleWrapperJar);
+        File gradleWrapperProps = new File(gradleWrapperDir, "gradle-wrapper.properties");
+        writeResourceToFile("/gradle/wrapper/gradle-wrapper.properties", gradleWrapperProps);
+    }
+
+    private static void writeResourceToFile(String resource, File target) throws IOException {
+        try (PrintWriter writer = new PrintWriter(target)) {
+            try (InputStream inputStream = DependencyResolver.class.getResourceAsStream(resource)) {
+                if (inputStream == null) {
+                    throw new FileNotFoundException("Not found: gradlew wrapper in resources!");
+                }
+                try (var os = new BufferedOutputStream(new FileOutputStream(target))) {
+                    byte[] buffer = new byte[8192]; // Buffer size of 8 KB
+                    int bytesRead;
+                    while ((bytesRead = inputStream.read(buffer)) != -1) {
+                        os.write(buffer, 0, bytesRead);
+                    }
+                }
+            }
+        }
     }
 
     private static void simpleLog(String message) {

Samples/JavaDependencySampleApp/Sources/JavaDependencySample/main.swift

@@ -20,6 +20,11 @@ import Foundation
 // Import the commons-csv library wrapper:
 import JavaCommonsCSV
 
+print("")
+print("")
+print("-----------------------------------------------------------------------")
+print("Start Sample app...")
+
 // Make sure we have the classpath loaded
 // TODO: this is more complex than that, need to account for dependencies of our module
 let currentDir = FileManager.default.currentDirectoryPath

Sources/Java2Swift/JavaToSwift+FetchDependencies.swift

@@ -33,9 +33,8 @@ extension JavaToSwift {
   }
 
   func fetchDependenciesCachedClasspath() -> [String]? {
-    guard let cachedClasspathURL = URL(string: "file://" + FileManager.default.currentDirectoryPath + "/" + JavaKitDependencyResolverClasspathCacheFilePath) else {
-      return []
-    }
+    let cachedClasspathURL = URL(
+      fileURLWithPath: FileManager.default.currentDirectoryPath + "/" + JavaKitDependencyResolverClasspathCacheFilePath)
 
     guard FileManager.default.fileExists(atPath: cachedClasspathURL.path) else {
       return []

Sources/Java2Swift/JavaToSwift.swift

@@ -255,20 +255,23 @@ struct JavaToSwift: ParsableCommand {
       }
 
       // Add extra classpath entries which are specific to building the JavaKit project and samples
-      let classpathBuildJavaKitEntries = [
-        "JavaKit/build/classes/java/main",
-        "../../JavaKit/build/classes/java/main",
-      ].filter {
-        FileManager.default.fileExists(atPath: $0)
-      }
+      let classpathBuildJavaKitEntries = [ // FIXME: THIS IS A TRICK UNTIL WE FIGURE OUT HOW TO BOOTSTRAP THIS PART
+        FileManager.default.currentDirectoryPath,
+        FileManager.default.currentDirectoryPath + "/.build",
+        FileManager.default.currentDirectoryPath + "/JavaKit/build/libs",
+        URL(fileURLWithPath: FileManager.default.currentDirectoryPath)
+          .deletingLastPathComponent()
+          .deletingLastPathComponent().absoluteURL.path + "/JavaKit/build/libs/JavaKit-1.0-SNAPSHOT.jar"
+      ]
       classpathEntries += classpathBuildJavaKitEntries
-
+    
       // Bring up the Java VM.
       // TODO: print only in verbose mode
-      let jvm = try JavaVirtualMachine.shared(classpath: classpathEntries)
       let classpath = classpathEntries.joined(separator: ":")
       print("[debug][swift-java] Initialize JVM with classpath: \(classpath)")
 
+      let jvm = try JavaVirtualMachine.shared(classpath: classpathEntries)
+
       // FIXME: we should resolve dependencies here perhaps
   //    if let dependencies = config.dependencies {
   //      print("[info][swift-java] Resolve dependencies...")
@@ -318,6 +321,8 @@ struct JavaToSwift: ParsableCommand {
           fatalError("Fetching dependencies must effective cache directory! Specify --output-directory or --cache-directory")
         }
 
+        print("[debug][swift-java] Base classpath to fetch dependencies: \(classpathOptionEntries)")
+
         let dependencyClasspath = try fetchDependencies(
           moduleName: moduleName,
           dependencies: dependencies,

Sources/JavaKit/JavaKitVM/JavaVirtualMachine.swift

@@ -73,8 +73,7 @@ public final class JavaVirtualMachine: @unchecked Sendable {
       for path in classpath {
         if !fileManager.fileExists(atPath: path) {
           // FIXME: this should be configurable, a classpath missing a directory isn't reason to blow up
-          print("[warning][swift-java][JavaVirtualMachine] Missing classpath element: \(path)") // TODO: stderr
-          // throw JavaKitError.classpathEntryNotFound(entry: path, classpath: classpath)
+          print("[warning][swift-java][JavaVirtualMachine] Missing classpath element: \(URL(fileURLWithPath: path).absoluteString)") // TODO: stderr
         }
       }
       let colonSeparatedClassPath = classpath.joined(separator: ":")
@@ -250,6 +249,7 @@ extension JavaVirtualMachine {
             // wrapper.
             let javaVirtualMachine = JavaVirtualMachine(adoptingJVM: jvm!)
             sharedJVMPointer = javaVirtualMachine
+            print("WAS EXISTING")
             return javaVirtualMachine
           }
 
@@ -261,6 +261,7 @@ extension JavaVirtualMachine {
           // Create a new instance of the JVM.
           let javaVirtualMachine: JavaVirtualMachine
           do {
+            print("CREATE")
             javaVirtualMachine = try JavaVirtualMachine(
               classpath: classpath,
               vmOptions: vmOptions,

Sources/JavaKitConfigurationShared/Configuration.swift

@@ -71,9 +71,18 @@ public struct JavaDependencyDescriptor: Hashable, Codable {
     let container = try decoder.singleValueContainer()
     let string = try container.decode(String.self)
     let parts = string.split(separator: ":")
+    
+    if parts.count == 1 && string.hasPrefix(":") {
+      self.groupID = ""
+      self.artifactID = ":" + String(parts.first!)
+      self.version = ""
+      return
+    }
+    
     guard parts.count == 3 else {
-      throw JavaDependencyDescriptorError(message: "Illegal dependency, did not match: `groupID:artifactID:version`")
+      throw JavaDependencyDescriptorError(message: "Illegal dependency, did not match: `groupID:artifactID:version`, parts: '\(parts)'")
     }
+    
     self.groupID = String(parts[0])
     self.artifactID = String(parts[1])
     self.version = String(parts[2])
@@ -96,14 +105,18 @@ public struct JavaDependencyDescriptor: Hashable, Codable {
 public func readConfiguration(sourceDir: String, file: String = #fileID, line: UInt = #line) throws -> Configuration {
   // Workaround since filePath is macOS 13
   let sourcePath =
-    if sourceDir.hasPrefix("file://") { sourceDir } else { "file://" + sourceDir }
-  let configFile = URL(string: sourcePath)!.appendingPathComponent("swift-java.config", isDirectory: false)
+  if sourceDir.hasPrefix("file://") { sourceDir } else { "file://" + sourceDir }
+  let configPath = URL(string: sourcePath)!.appendingPathComponent("swift-java.config", isDirectory: false)
+  
+  return try readConfiguration(configPath: configPath, file: file, line: line)
+}
 
+public func readConfiguration(configPath: URL, file: String = #fileID, line: UInt = #line) throws -> Configuration {
   do {
-    let configData = try Data(contentsOf: configFile)
+    let configData = try Data(contentsOf: configPath)
     return try JSONDecoder().decode(Configuration.self, from: configData)
   } catch {
-    throw ConfigurationError(message: "Failed to parse SwiftJava configuration at '\(configFile)'!", error: error,
+    throw ConfigurationError(message: "Failed to parse SwiftJava configuration at '\(configPath)'!", error: error,
       file: file, line: line)
   }
 }
@@ -125,6 +138,9 @@ public func findSwiftJavaClasspaths(in basePath: String = FileManager.default.cu
       print("[debug][swift-java] Constructing classpath with entries from: \(fileURL.relativePath)")
       if let contents = try? String(contentsOf: fileURL) {
         let entries = contents.split(separator: ":").map(String.init)
+        for entry in entries {
+          print("[debug][swift-java] Classpath += \(entry)")
+        }
         classpathEntries += entries
       }
     }

Sources/JavaKitDependencyResolver/swift-java.config

@@ -1,8 +1,9 @@
 {
-     "dependencies": [
-         "dev.gradleplugins:gradle-api:8.10.1"
-     ],
-     "classes": {
-         "org.swift.javakit.dependencies.DependencyResolver": "DependencyResolver"
-     }
- }
+    "dependencies": [
+        ":JavaKit",
+    ]
+    ,
+    "__classes": {
+        "org.swift.javakit.dependencies.DependencyResolver": "DependencyResolver"
+    }
+ }