wip

Author: ktoso

Plugins/JExtractSwiftCommandPlugin/JExtractSwiftCommandPlugin.swift

@@ -69,21 +69,21 @@ final class JExtractSwiftCommandPlugin: SwiftJavaPluginProtocol, BuildToolPlugin
     let sourceDir = target.directory.string
 
     let configuration = try readConfiguration(sourceDir: "\(sourceDir)")
-    guard let javaPackage = configuration.javaPackage else {
-      throw SwiftJavaPluginError.missingConfiguration(sourceDir: "\(sourceDir)", key: "javaPackage")
-    }
 
     var arguments: [String] = [
+      "--input-swift", sourceDir,
       "--swift-module", sourceModule.name,
-      "--package-name", javaPackage,
-      "--output-directory-java", context.outputDirectoryJava.path(percentEncoded: false),
-      "--output-directory-swift", context.outputDirectorySwift.path(percentEncoded: false),
+      "--output-java", context.outputJavaDirectory.path(percentEncoded: false),
+      "--output-swift", context.outputSwiftDirectory.path(percentEncoded: false),
       // TODO: "--build-cache-directory", ...
       //       Since plugins cannot depend on libraries we cannot detect what the output files will be,
       //       as it depends on the contents of the input files. Therefore we have to implement this as a prebuild plugin.
       //       We'll have to make up some caching inside the tool so we don't re-parse files which have not changed etc.
     ]
-    arguments.append(sourceDir)
+    // arguments.append(sourceDir) // TODO: we could do this shape maybe? to have the dirs last?
+    if let package = configuration.javaPackage, !package.isEmpty {
+      ["--java-package", package]
+    }
 
     return arguments
   }

Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift

@@ -50,20 +50,23 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
 
     // We use the the usual maven-style structure of "src/[generated|main|test]/java/..."
     // that is common in JVM ecosystem
-    let outputDirectoryJava = context.outputDirectoryJava
-    let outputDirectorySwift = context.outputDirectorySwift
+    let outputJavaDirectory = context.outputJavaDirectory
+    let outputSwiftDirectory = context.outputSwiftDirectory
 
     var arguments: [String] = [
+      "--input-swift", sourceDir,
       "--swift-module", sourceModule.name,
-      "--package-name", javaPackage,
-      "--output-directory-java", outputDirectoryJava.path(percentEncoded: false),
-      "--output-directory-swift", outputDirectorySwift.path(percentEncoded: false),
+      "--output-java", outputJavaDirectory.path(percentEncoded: false),
+      "--output-swift", outputSwiftDirectory.path(percentEncoded: false),
       // TODO: "--build-cache-directory", ...
       //       Since plugins cannot depend on libraries we cannot detect what the output files will be,
       //       as it depends on the contents of the input files. Therefore we have to implement this as a prebuild plugin.
       //       We'll have to make up some caching inside the tool so we don't re-parse files which have not changed etc.
     ]
-    arguments.append(sourceDir)
+    // arguments.append(sourceDir)
+    if !javaPackage.isEmpty {
+      arguments.append(contentsOf: ["--java-package", javaPackage])
+    }
 
     return [
       .prebuildCommand(
@@ -72,7 +75,7 @@ struct JExtractSwiftBuildToolPlugin: SwiftJavaPluginProtocol, BuildToolPlugin {
         arguments: arguments,
         // inputFiles: [ configFile ] + swiftFiles,
         // outputFiles: outputJavaFiles
-        outputFilesDirectory: outputDirectorySwift
+        outputFilesDirectory: outputSwiftDirectory
       )
     ]
   }

Plugins/PluginsShared/PluginUtils.swift

@@ -60,14 +60,14 @@ func getEnvironmentBool(_ name: String) -> Bool {
 }
 
 extension PluginContext {
-  var outputDirectoryJava: URL {
+  var outputJavaDirectory: URL {
     self.pluginWorkDirectoryURL
       .appending(path: "src")
       .appending(path: "generated")
       .appending(path: "java")
   }
 
-  var outputDirectorySwift: URL {
+  var outputSwiftDirectory: URL {
     self.pluginWorkDirectoryURL
       .appending(path: "Sources")
   }

Sources/JExtractSwiftLib/Logger.swift

@@ -14,6 +14,8 @@
 
 import Foundation
 import SwiftSyntax
+import ArgumentParser
+import JavaKitConfigurationShared
 
 // Placeholder for some better logger, we could depend on swift-log
 public struct Logger {
@@ -95,47 +97,17 @@ public struct Logger {
 }
 
 extension Logger {
-  public enum Level: String, Hashable {
-    case trace = "trace"
-    case debug = "debug"
-    case info = "info"
-    case notice = "notice"
-    case warning = "warning"
-    case error = "error"
-    case critical = "critical"
-  }
+  public typealias Level = JavaKitConfigurationShared.LogLevel
 }
 
-extension Logger.Level {
-  public init(from decoder: any Decoder) throws {
-    var container = try decoder.unkeyedContainer()
-    let string = try container.decode(String.self)
-    switch string {
-    case "trace": self = .trace
-    case "debug": self = .debug
-    case "info": self = .info
-    case "notice": self = .notice
-    case "warning": self = .warning
-    case "error": self = .error
-    case "critical": self = .critical
-    default: fatalError("Unknown value for \(Logger.Level.self): \(string)")
-    }
+extension Logger.Level: ExpressibleByArgument {
+  public var defaultValueDescription: String {
+    "log level"
   }
+  public private(set) static var allValueStrings: [String] =
+    ["trace", "debug", "info", "notice", "warning", "error", "critical"]
 
-  public func encode(to encoder: any Encoder) throws {
-    var container = encoder.singleValueContainer()
-    let text =
-      switch self {
-      case .trace: "trace"
-      case .debug: "debug"
-      case .info: "info"
-      case .notice: "notice"
-      case .warning: "warning"
-      case .error: "error"
-      case .critical: "critical"
-      }
-    try container.encode(text)
-  }
+  public private(set) static var defaultCompletionKind: CompletionKind = .default
 }
 
 extension Logger.Level {

Sources/JExtractSwiftLib/Swift2Java.swift

@@ -17,50 +17,31 @@ import Foundation
 import SwiftSyntax
 import SwiftSyntaxBuilder
 import JavaKitShared
+import JavaKitConfigurationShared // TODO: this should become SwiftJavaConfigurationShared
 
-/// Command-line utility, similar to `jextract` to export Swift types to Java.
-public struct SwiftToJava: ParsableCommand {
-  public init() {}
+public struct SwiftToJava {
 
-  public static var _commandName: String {
-    "jextract-swift"
-  }
-
-  @Option(help: "The package the generated Java code should be emitted into.")
-  var packageName: String
-
-  @Option(
-    name: .shortAndLong,
-    help: "The directory in which to output the generated Swift files and manifest.")
-  var outputDirectoryJava: String = ".build/jextract-swift/generated"
-
-  @Option(help: "Swift output directory")
-  var outputDirectorySwift: String
-
-  @Option(
-    name: .long,
-    help: "Name of the Swift module to import (and the swift interface files belong to)")
-  var swiftModule: String
-
-  @Option(name: .shortAndLong, help: "Configure the level of lots that should be printed")
-  var logLevel: Logger.Level = .info
-
-  @Argument(help: "The Swift files or directories to recursively export to Java.")
-  var input: [String]
-
-  public func run() throws {
-    let inputPaths = self.input.dropFirst().map { URL(string: $0)! }
+  public func run(config: Configuration) throws {
+    guard let swiftModule = config.swiftModule else {
+      fatalError("Missing '--swift-module' name.")
+    }
 
     let translator = Swift2JavaTranslator(
-      javaPackage: packageName,
+      javaPackage: config.javaPackage ?? "", // no package is ok, we'd generate all into top level
       swiftModuleName: swiftModule
     )
-    translator.log.logLevel = logLevel
+    translator.log.logLevel = config.logLevel ?? .info
+
+    if config.javaPackage == nil || config.javaPackage!.isEmpty {
+      translator.log.warning("Configured java package is '', consider specifying concrete package for generated sources.")
+    }
+
+    let inputPaths = (config.inputSwiftDirectory ?? "").split(separator: ",").dropFirst().map { URL(string: String($0))! }
 
     var allFiles: [URL] = []
     let fileManager = FileManager.default
     let log = translator.log
-    
+
     for path in inputPaths {
       log.debug("Input path: \(path)")
       if isDirectory(url: path) {
@@ -88,10 +69,17 @@ public struct SwiftToJava: ParsableCommand {
       translator.add(filePath: file.path, text: text)
     }
 
+    guard let outputSwiftDirectory = config.outputSwiftDirectory else {
+      fatalError("Missing --output-swift directory!")
+    }
+    guard let outputJavaDirectory = config.outputJavaDirectory else {
+      fatalError("Missing --output-java directory!")
+    }
+
     try translator.analyze()
-    try translator.writeSwiftThunkSources(outputDirectory: outputDirectorySwift)
-    try translator.writeExportedJavaSources(outputDirectory: outputDirectoryJava)
-    print("[swift-java] Generated Java sources (\(packageName)) in: \(outputDirectoryJava)/")
+    try translator.writeSwiftThunkSources(outputDirectory: outputSwiftDirectory)
+    try translator.writeExportedJavaSources(outputDirectory: outputJavaDirectory)
+    print("[swift-java] Generated Java sources (\(config.javaPackage ?? "")) in: \(outputJavaDirectory)/")
     print("[swift-java] Imported Swift module '\(swiftModule)': " + "done.".green)
   }
 
@@ -102,16 +90,6 @@ public struct SwiftToJava: ParsableCommand {
 
 }
 
-extension Logger.Level: ExpressibleByArgument {
-  public var defaultValueDescription: String {
-    "log level"
-  }
-  public private(set) static var allValueStrings: [String] =
-    ["trace", "debug", "info", "notice", "warning", "error", "critical"]
-
-  public private(set) static var defaultCompletionKind: CompletionKind = .default
-}
-
 func isDirectory(url: URL) -> Bool {
   var isDirectory: ObjCBool = false
   _ = FileManager.default.fileExists(atPath: url.path, isDirectory: &isDirectory)

Sources/JavaKitConfigurationShared/Configuration.swift

@@ -21,15 +21,22 @@ import Foundation
 
 public typealias JavaVersion = Int
 
-/// Configuration for the SwiftJava plugins, provided on a per-target basis.
+/// Configuration for the SwiftJava tools and plugins, provided on a per-target basis.
 public struct Configuration: Codable {
-  // ==== swift 2 java ---------------------------------------------------------
+
+  public var logLevel: LogLevel?
+
+  // ==== swift 2 java / jextract swift ---------------------------------------
 
   public var javaPackage: String?
 
-  public var inputSwift: String?
-  public var outputSwift: String?
-  public var outputJava: String?
+  public var swiftModule: String?
+
+  public var inputSwiftDirectory: String?
+
+  public var outputSwiftDirectory: String?
+
+  public var outputJavaDirectory: String?
 
   // ==== java 2 swift ---------------------------------------------------------
 
@@ -204,3 +211,45 @@ public struct ConfigurationError: Error {
     self.line = line
   }
 }
+
+public enum LogLevel: String, Codable, Hashable {
+  case trace = "trace"
+  case debug = "debug"
+  case info = "info"
+  case notice = "notice"
+  case warning = "warning"
+  case error = "error"
+  case critical = "critical"
+}
+
+extension LogLevel {
+  public init(from decoder: any Decoder) throws {
+    var container = try decoder.unkeyedContainer()
+    let string = try container.decode(String.self)
+    switch string {
+    case "trace": self = .trace
+    case "debug": self = .debug
+    case "info": self = .info
+    case "notice": self = .notice
+    case "warning": self = .warning
+    case "error": self = .error
+    case "critical": self = .critical
+    default: fatalError("Unknown value for \(LogLevel.self): \(string)")
+    }
+  }
+
+  public func encode(to encoder: any Encoder) throws {
+    var container = encoder.singleValueContainer()
+    let text =
+      switch self {
+      case .trace: "trace"
+      case .debug: "debug"
+      case .info: "info"
+      case .notice: "notice"
+      case .warning: "warning"
+      case .error: "error"
+      case .critical: "critical"
+      }
+    try container.encode(text)
+  }
+}