move the configure command into its own file/subcommand

Author: ktoso

.swift-version

@@ -0,0 +1 @@
+6.1.2

Samples/JavaDependencySampleApp/Sources/Test/swift-java.config

@@ -12,37 +12,339 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 import ArgumentParser
+import Foundation
 import SwiftJavaLib
+import JExtractSwiftLib
 import JavaKit
 import JavaKitJar
+import JavaKitNetwork
+import JavaKitReflection
+import SwiftSyntax
+import SwiftSyntaxBuilder
 import JavaKitConfigurationShared
+import JavaKitShared
+
+protocol HasCommonOptions {
+  var commonOptions: SwiftJava.CommonOptions { get set }
+}
+
+protocol HasCommonJVMOptions {
+  var commonJVMOptions: SwiftJava.CommonJVMOptions { get set }
+}
+
+extension SwiftJava {
+  struct CommonOptions: ParsableArguments {
+    // TODO: clarify this vs outputSwift (history: outputSwift is jextract, and this was java2swift)
+    @Option(name: .shortAndLong, help: "The directory in which to output the generated Swift files or the SwiftJava configuration file.")
+    var outputDirectory: String? = nil
+
+    @Option(help: "Directory containing Swift files which should be extracted into Java bindings. Also known as 'jextract' mode. Must be paired with --output-java and --output-swift.")
+    var inputSwift: String? = nil
+
+    @Option(name: .shortAndLong, help: "Configure the level of logs that should be printed")
+    var logLevel: Logger.Level = .info
+  }
+
+  struct CommonJVMOptions: ParsableArguments {
+    @Option(
+      name: [.customLong("cp"), .customLong("classpath")],
+      help: "Class search path of directories and zip/jar files from which Java classes can be loaded."
+    )
+    var classpath: [String] = []
+
+    @Option(name: .shortAndLong, help: "While scanning a classpath, inspect only types included in this package")
+    var filterJavaPackage: String? = nil
+  }
+}
+
+protocol SwiftJavaBaseAsyncParsableCommand: AsyncParsableCommand {
+  var logLevel: Logger.Level { get set }
+
+  var commonOptions: SwiftJava.CommonOptions { get set }
+
+  var moduleName: String? { get }
+
+  mutating func runSwiftJavaCommand(config: inout Configuration) async throws
+
+}
+
+extension SwiftJavaBaseAsyncParsableCommand {
+  mutating func writeContents(
+    _ contents: String,
+    to filename: String, description: String) throws {
+    try writeContents(
+      contents,
+      outputDirectoryOverride: self.actualOutputDirectory,
+      to: filename,
+      description: description)
+  }
+
+  mutating func writeContents(
+    _ contents: String,
+    outputDirectoryOverride: Foundation.URL?,
+    to filename: String,
+    description: String) throws {
+    guard let outputDir = (outputDirectoryOverride ?? actualOutputDirectory) else {
+      print("// \(filename) - \(description)")
+      print(contents)
+      return
+    }
+
+    // If we haven't tried to create the output directory yet, do so now before
+    // we write any files to it.
+    // if !createdOutputDirectory {
+    try FileManager.default.createDirectory(
+      at: outputDir,
+      withIntermediateDirectories: true
+    )
+    // createdOutputDirectory = true
+    //}
+
+    // Write the file:
+    let file = outputDir.appendingPathComponent(filename)
+    print("[debug][swift-java] Writing \(description) to '\(file.path)'... ", terminator: "")
+    try contents.write(to: file, atomically: true, encoding: .utf8)
+    print("done.".green)
+  }
+}
+
+extension SwiftJavaBaseAsyncParsableCommand {
+  public mutating func run() async {
+    print("[info][swift-java] Run: \(CommandLine.arguments.joined(separator: " "))")
+    print("[info][swift-java] Current work directory: \(URL(fileURLWithPath: "."))")
+
+    do {
+      var config = try readInitialConfiguration(command: self)
+      try await runSwiftJavaCommand(config: &config)
+    } catch {
+      // We fail like this since throwing out of the run often ends up hiding the failure reason when it is executed as SwiftPM plugin (!)
+      let message = "Failed with error: \(error)"
+      print("[error][java-swift] \(message)")
+      fatalError(message)
+    }
+
+    // Just for debugging so it is clear which command has finished
+    print("[debug][swift-java] " + "Done: ".green + CommandLine.arguments.joined(separator: " ").green)
+  }
+}
+
+extension SwiftJavaBaseAsyncParsableCommand {
+  var logLevel: Logger.Level {
+    get {
+      self.commonOptions.logLevel
+    }
+    set {
+    self.commonOptions.logLevel = newValue
+    }
+  }
+}
+extension SwiftJavaBaseAsyncParsableCommand {
+
+  var moduleBaseDir: Foundation.URL? {
+    if let outputDirectory = commonOptions.outputDirectory {
+      if outputDirectory == "-" {
+        return nil
+      }
+
+      print("[debug][swift-java] Module base directory based on outputDirectory!")
+      return URL(fileURLWithPath: outputDirectory)
+    }
+
+    guard let moduleName else {
+      return nil
+    }
+
+    // Put the result into Sources/\(moduleName).
+    let baseDir = URL(fileURLWithPath: ".")
+      .appendingPathComponent("Sources", isDirectory: true)
+      .appendingPathComponent(moduleName, isDirectory: true)
+
+    return baseDir
+  }
+
+  /// The output directory in which to place the generated files, which will
+  /// be the specified directory (--output-directory or -o option) if given,
+  /// or a default directory derived from the other command-line arguments.
+  ///
+  /// Returns `nil` only when we should emit the files to standard output.
+  var actualOutputDirectory: Foundation.URL? {
+    if let outputDirectory = commonOptions.outputDirectory {
+      if outputDirectory == "-" {
+        return nil
+      }
+
+      return URL(fileURLWithPath: outputDirectory)
+    }
+
+    guard let moduleName else {
+      fatalError("--module-name must be set!")
+    }
+
+    // Put the result into Sources/\(moduleName).
+    let baseDir = URL(fileURLWithPath: ".")
+      .appendingPathComponent("Sources", isDirectory: true)
+      .appendingPathComponent(moduleName, isDirectory: true)
+
+    // For generated Swift sources, put them into a "generated" subdirectory.
+    // The configuration file goes at the top level.
+    let outputDir: Foundation.URL
+//    if jar {
+      // precondition(self.input != nil, "-jar mode requires path to jar to be specified as input path")
+      outputDir = baseDir
+//    } else {
+//      outputDir = baseDir
+//        .appendingPathComponent("generated", isDirectory: true)
+//    }
+
+    return outputDir
+  }
+
+  func readInitialConfiguration(command: some SwiftJavaBaseAsyncParsableCommand) throws -> Configuration {
+    var earlyConfig: Configuration?
+    if let moduleBaseDir {
+      print("[debug][swift-java] Load config from module base directory: \(moduleBaseDir.path)")
+      earlyConfig = try readConfiguration(sourceDir: moduleBaseDir.path)
+    } else if let inputSwift = commonOptions.inputSwift {
+      print("[debug][swift-java] Load config from module swift input directory: \(inputSwift)")
+      earlyConfig = try readConfiguration(sourceDir: inputSwift)
+    }
+    var config = earlyConfig ?? Configuration()
+    // override configuration with options from command line
+    config.logLevel = command.logLevel
+    return config
+  }
+}
 
 extension SwiftJava {
+  struct ConfigureCommand: SwiftJavaBaseAsyncParsableCommand, HasCommonOptions, HasCommonJVMOptions {
+    static let configuration = CommandConfiguration(
+      commandName: "configure",
+      abstract: "Configure and emit a swift-java.config file based on an input dependency or jar file")
+
+    // TODO: This should be a "make wrappers" option that just detects when we give it a jar
+    @Flag(
+      help: "Specifies that the input is a *.jar file whose public classes will be loaded. The output of swift-java will be a configuration file (swift-java.config) that can be used as input to a subsequent swift-java invocation to generate wrappers for those public classes."
+    )
+    var jar: Bool = false
+
+    @Option(
+      name: .long,
+      help: "How to handle an existing swift-java.config; by default 'overwrite' by can be changed to amending a configuration"
+    )
+    var existingConfigFile: ExistingConfigFileMode = .overwrite
+    enum ExistingConfigFileMode: String, ExpressibleByArgument, Codable {
+      case overwrite
+      case amend
+    }
+
+    // FIXME: is it used?
+    @Option(help: "The name of the Swift module into which the resulting Swift types will be generated.")
+    var moduleName: String? // TODO: rename to --swift-module?
+
+    @OptionGroup var commonOptions: SwiftJava.CommonOptions
+    @OptionGroup var commonJVMOptions: SwiftJava.CommonJVMOptions
+
+    @Argument(
+      help: "The input file, which is either a swift-java configuration file or (if '-jar' was specified) a Jar file."
+    )
+    var input: String = ""
+  }
+}
+
+extension SwiftJava.ConfigureCommand {
+  mutating func runSwiftJavaCommand(config: inout Configuration) async throws {
+    // Form a class path from all of our input sources:
+    //   * Command-line option --classpath
+    let classpathOptionEntries: [String] = self.commonJVMOptions.classpath.flatMap { $0.split(separator: ":").map(String.init) }
+    let classpathFromEnv = ProcessInfo.processInfo.environment["CLASSPATH"]?.split(separator: ":").map(String.init) ?? []
+    let classpathFromConfig: [String] = config.classpath?.split(separator: ":").map(String.init) ?? []
+    print("[debug][swift-java] Base classpath from config: \(classpathFromConfig)")
+
+    var classpathEntries: [String] = classpathFromConfig
+
+    let swiftJavaCachedModuleClasspath = findSwiftJavaClasspaths(in:
+    // self.effectiveCacheDirectory ??
+    FileManager.default.currentDirectoryPath)
+    print("[debug][swift-java] Classpath from *.swift-java.classpath files: \(swiftJavaCachedModuleClasspath)")
+    classpathEntries += swiftJavaCachedModuleClasspath
+
+    if !classpathOptionEntries.isEmpty {
+      print("[debug][swift-java] Classpath from options: \(classpathOptionEntries)")
+      classpathEntries += classpathOptionEntries
+    } else {
+      // * Base classpath from CLASSPATH env variable
+      print("[debug][swift-java] Classpath from environment: \(classpathFromEnv)")
+      classpathEntries += classpathFromEnv
+    }
+
+    let extraClasspath = input // FIXME: just use the -cp as usual
+    let extraClasspathEntries = extraClasspath.split(separator: ":").map(String.init)
+    print("[debug][swift-java] Extra classpath: \(extraClasspathEntries)")
+    classpathEntries += extraClasspathEntries
+
+    // Bring up the Java VM when necessary
+
+    if logLevel >= .debug {
+      let classpathString = classpathEntries.joined(separator: ":")
+      print("[debug][swift-java] Initialize JVM with classpath: \(classpathString)")
+    }
+    let jvm = try JavaVirtualMachine.shared(classpath: classpathEntries)
+
+    try emitConfiguration(classpath: self.commonJVMOptions.classpath, environment: jvm.environment())
+  }
+
+  /// Get base configuration, depending on if we are to 'amend' or 'overwrite' the existing configuration.
+  func getBaseConfigurationForWrite() throws -> (Bool, Configuration) {
+    guard let actualOutputDirectory = self.actualOutputDirectory else {
+      // If output has no path there's nothing to amend
+      return (false, .init())
+    }
+
+    switch self.existingConfigFile {
+    case .overwrite:
+      // always make up a fresh instance if we're overwriting
+      return (false, .init())
+    case .amend:
+      let configPath = actualOutputDirectory
+      guard let config = try readConfiguration(sourceDir: configPath.path) else {
+        return (false, .init())
+      }
+      return (true, config)
+    }
+  }
 
   // TODO: make this perhaps "emit type mappings"
   mutating func emitConfiguration(
-    classpath: String,
+    classpath: [String],
     environment: JNIEnvironment
   ) throws {
-    print("[java-swift] Generate Java->Swift type mappings. Active filter: \(javaPackageFilter)")
-    print("[java-swift] Classpath: \(classpath)")
+    if let filterJavaPackage = self.commonJVMOptions.filterJavaPackage {
+      print("[java-swift][debug] Generate Java->Swift type mappings. Active filter: \(filterJavaPackage)")
+    }
+    print("[java-swift][debug] Classpath: \(classpath)")
 
     if classpath.isEmpty {
-      print("[warning][java-swift] Classpath is empty!")
+      print("[java-swift][warning] Classpath is empty!")
     }
 
     // Get a fresh or existing configuration we'll amend
     var (amendExistingConfig, configuration) = try getBaseConfigurationForWrite()
     if amendExistingConfig {
       print("[swift-java] Amend existing swift-java.config file...")
     }
-    configuration.classpath = classpath // TODO: is this correct?
+    configuration.classpath = classpath.joined(separator: ":") // TODO: is this correct?
 
     // Import types from all the classpath entries;
     // Note that we use the package level filtering, so users have some control over what gets imported.
-    for entry in classpath.split(separator: ":").map(String.init) {
+    let classpathEntries = classpath.split(separator: ":").map(String.init)
+    for entry in classpathEntries {
+      guard fileOrDirectoryExists(at: entry) else {
+        // We only log specific jars missing, as paths may be empty directories that won't hurt not existing.
+        print("[debug][swift-java] Classpath entry does not exist: \(entry)")
+        continue
+      }
+
       print("[debug][swift-java] Importing classpath entry: \(entry)")
       if entry.hasSuffix(".jar") {
         let jarFile = try JarFile(entry, false, environment: environment)
@@ -70,10 +372,10 @@ extension SwiftJava {
   }
 
   mutating func addJavaToSwiftMappings(
-      to configuration: inout Configuration,
-      forJar jarFile: JarFile,
-      environment: JNIEnvironment
-    ) throws {
+    to configuration: inout Configuration,
+    forJar jarFile: JarFile,
+    environment: JNIEnvironment
+  ) throws {
     for entry in jarFile.entries()! {
       // We only look at class files in the Jar file.
       guard entry.getName().hasSuffix(".class") else {
@@ -99,11 +401,10 @@ extension SwiftJava {
       let javaCanonicalName = String(entry.getName().replacing("/", with: ".")
         .dropLast(".class".count))
 
-      if let javaPackageFilter {
-        if !javaCanonicalName.hasPrefix(javaPackageFilter) {
-          // Skip classes which don't match our expected prefix
-          continue
-        }
+      if let filterJavaPackage = self.commonJVMOptions.filterJavaPackage,
+         !javaCanonicalName.hasPrefix(filterJavaPackage) {
+        // Skip classes which don't match our expected prefix
+        continue
       }
 
       if configuration.classes?[javaCanonicalName] != nil {
@@ -117,4 +418,9 @@ extension SwiftJava {
     }
   }
 
+}
+
+package func fileOrDirectoryExists(at path: String) -> Bool {
+  var isDirectory: ObjCBool = false
+  return FileManager.default.fileExists(atPath: path, isDirectory: &isDirectory)
 }