adopt Swift ArgumentParser in unidoc-preview

Author: tayloraswift

Package.swift

@@ -137,7 +137,7 @@ let package:Package = .init(
 
         .executableTarget(name: "unidoc-preview",
             dependencies: [
-                .target(name: "ArgumentParsing"),
+                .target(name: "System_ArgumentParser"),
                 .target(name: "UnidocServer"),
             ]),
 
@@ -359,12 +359,12 @@ let package:Package = .init(
 
         .target(name: "SymbolGraphBuilder",
             dependencies: [
-                .product(name: "ArgumentParser", package: "swift-argument-parser"),
                 .target(name: "MarkdownPluginSwift"),
                 .target(name: "MarkdownPluginSwift_IndexStoreDB"),
                 .target(name: "PackageMetadata"),
                 .target(name: "SymbolGraphCompiler"),
                 .target(name: "SymbolGraphLinker"),
+                .target(name: "System_ArgumentParser"),
                 .target(name: "System"),
             ]),
 
@@ -564,6 +564,12 @@ let package:Package = .init(
                 .product(name: "TraceableErrors", package: "swift-grammar"),
             ]),
 
+        .target(name: "System_ArgumentParser",
+            dependencies: [
+                .target(name: "System"),
+                .product(name: "ArgumentParser", package: "swift-argument-parser"),
+            ]),
+
         .executableTarget(name: "UCFTests",
             dependencies: [
                 .target(name: "UCF"),

Sources/SymbolGraphBuilder/SSGC.Compile.swift

@@ -2,6 +2,7 @@ import ArgumentParser
 import BSON
 import SymbolGraphs
 import Symbols
+import System_ArgumentParser
 import System
 
 extension SSGC

Sources/SymbolGraphBuilder/FilePath (ext).swift renamed to Sources/System_ArgumentParser/FilePath (ext).swift

@@ -38,7 +38,7 @@ extension Unidoc.ServerOptions
         var port:Int
 
         @inlinable public
-        init()
+        init(replicaSet:String = "unidoc-rs")
         {
             self.cloudfront = false
 
@@ -47,7 +47,7 @@ extension Unidoc.ServerOptions
             self.runPolicy = false
             self.security = .ignored
 
-            self.replicaSet = "unidoc-rs"
+            self.replicaSet = replicaSet
             self.bucket = nil
             self.port = 8443
         }

Sources/SymbolGraphBuilder/FilePath.Directory (ext).swift renamed to Sources/System_ArgumentParser/FilePath.Directory (ext).swift

@@ -0,0 +1,6 @@
+import ArgumentParser
+import MongoClusters
+
+extension Mongo.Host:ExpressibleByArgument
+{
+}

Sources/UnidocServer/Configurations/Unidoc.ServerOptions.Development.swift

@@ -1,141 +1,127 @@
-import ArgumentParsing
-import GitHubAPI
+import ArgumentParser
 import HTTPServer
 import MongoDB
 import NIOPosix
 import NIOSSL
+import System_ArgumentParser
 import System
 import UnidocServer
 
 extension Unidoc
 {
     struct Preview
     {
-        var certificates:String
-
-        var development:Unidoc.ServerOptions.Development
-        var mirror:Bool
-        var https:Bool
-        var mongo:Mongo.Host
-
-        private
-        init() throws
+        @Option(
+            name: [.customLong("certificates"), .customShort("c")],
+            help: "A path to the certificates directory",
+            completion: .directory)
+        var certificates:FilePath.Directory = "Assets/certificates"
+
+        @Option(
+            name: [.customLong("mongo"), .customShort("m")],
+            help: "The name of a host running mongod to connect to, and optionally, the port")
+        var mongod:Mongo.Host = "localhost"
+
+        @Option(
+            name: [.customLong("replica-set"), .customShort("s")],
+            help: "The name of a replica set to connect to")
+        var replicaSet:String = "unidoc-rs"
+
+        @Option(
+            name: [.customLong("port"), .customShort("p")],
+            help: "The number of a port to bind the documentation server to")
+        var port:Int?
+
+        @Flag(
+            name: [.customLong("mirror"), .customShort("q")],
+            help: "Run in mirror mode, disabling the documentation linker process")
+        var mirror:Bool = false
+
+        @Flag(
+            name: [.customLong("https"), .customShort("e")],
+            help: "Use https instead of http")
+        var https:Bool = false
+
+        init()
         {
-            self.certificates = "Assets/certificates"
-            self.development = .init()
-            self.development.port = 8080
-            self.mirror = false
-            self.https = false
-            self.mongo = "localhost"
         }
     }
 }
 extension Unidoc.Preview
 {
-    private mutating
-    func parse() throws
+    private
+    var serverSSL:NIOSSLContext
     {
-        var arguments:CommandLine.Arguments = .init()
-
-        while let argument:String = arguments.next()
+        get throws
         {
-            switch argument
-            {
-            case "-c", "--certificates":
-                self.certificates = try arguments.next(for: "certificates")
+            let privateKeyPath:FilePath = self.certificates / "privkey.pem"
+            let privateKey:NIOSSLPrivateKey = try .init(file: "\(privateKeyPath)", format: .pem)
 
-            case "-q", "--mirror":
-                self.mirror = true
+            let fullChainPath:FilePath = self.certificates / "fullchain.pem"
+            let fullChain:[NIOSSLCertificate] = try NIOSSLCertificate.fromPEMFile(
+                "\(fullChainPath)")
 
-            case "-s", "--replica-set":
-                self.development.replicaSet = try arguments.next(for: "replica-set")
-
-            case "-e", "--https":
-                self.https = true
-                self.development.port = 8443
-
-            case "-m", "--mongo":
-                self.mongo = .init(try arguments.next(for: "mongo"))
+            var configuration:TLSConfiguration = .makeServerConfiguration(
+                certificateChain: fullChain.map(NIOSSLCertificateSource.certificate(_:)),
+                privateKey: .privateKey(privateKey))
 
-            case "-p", "--port":
-                self.https = true
-                self.development.port = try arguments.next(for: "port")
+                // configuration.applicationProtocols = ["h2", "http/1.1"]
+                configuration.applicationProtocols = ["h2"]
 
-            case let option:
-                throw CommandLine.ArgumentError.unknown(option)
-            }
+            return try .init(configuration: configuration)
         }
     }
-}
 
-@main
-extension Unidoc.Preview
-{
-    static
-    func main() async throws
+    private
+    var clientSSL:NIOSSLContext
     {
-        var main:Self = try .init()
-        try main.parse()
-        try await main.launch()
+        get throws
+        {
+            var configuration:TLSConfiguration = .makeClientConfiguration()
+                configuration.applicationProtocols = ["h2"]
+            return try .init(configuration: configuration)
+        }
     }
 }
-extension Unidoc.Preview
+
+@main
+extension Unidoc.Preview:AsyncParsableCommand
 {
-    private consuming
-    func options() throws -> Unidoc.ServerOptions
+    func run() async throws
     {
-        let authority:any HTTP.ServerAuthority
-        if  self.https
-        {
-            let privateKey:NIOSSLPrivateKey =
-                try .init(file: "\(self.certificates)/privkey.pem", format: .pem)
-            let fullChain:[NIOSSLCertificate] =
-                try NIOSSLCertificate.fromPEMFile("\(self.certificates)/fullchain.pem")
+        let threads:MultiThreadedEventLoopGroup = .init(numberOfThreads: 2)
 
-            var configuration:TLSConfiguration = .makeServerConfiguration(
-                certificateChain: fullChain.map(NIOSSLCertificateSource.certificate(_:)),
-                privateKey: .privateKey(privateKey))
+        defer
+        {
+            try? threads.syncShutdownGracefully()
+        }
 
-                // configuration.applicationProtocols = ["h2", "http/1.1"]
-                configuration.applicationProtocols = ["h2"]
+        var development:Unidoc.ServerOptions.Development = .init(replicaSet: self.replicaSet)
+        let authority:any HTTP.ServerAuthority
 
-            authority = HTTP.LocalhostSecure.init(
-                context: try .init(configuration: configuration))
+        if  self.https
+        {
+            authority = HTTP.LocalhostSecure.init(context: try self.serverSSL)
+            development.port = self.port ?? 8443
         }
         else
         {
             authority = HTTP.Localhost.init()
+            development.port = self.port ?? 8080
         }
 
-        return .init(authority: authority,
+        let options:Unidoc.ServerOptions = .init(authority: authority,
             github: nil,
             mirror: self.mirror,
             bucket: .init(
-                assets: self.development.bucket,
-                graphs: self.development.bucket),
-            mode: .development(.init(source: "Assets"), self.development))
-    }
-
-    private consuming
-    func launch() async throws
-    {
-        let threads:MultiThreadedEventLoopGroup = .init(numberOfThreads: 2)
-
-        defer
-        {
-            try? threads.syncShutdownGracefully()
-        }
-
-        let mongod:Mongo.Host = self.mongo
-
-        var configuration:TLSConfiguration = .makeClientConfiguration()
-            configuration.applicationProtocols = ["h2"]
+                assets: development.bucket,
+                graphs: development.bucket),
+            mode: .development(.init(source: "Assets"), development))
 
         let context:Unidoc.ServerPluginContext = .init(threads: threads,
-            niossl: try .init(configuration: configuration))
-        let options:Unidoc.ServerOptions = try self.options()
+            niossl: try self.clientSSL)
 
-        let mongodb:Mongo.DriverBootstrap = MongoDB / [mongod] /?
+        let mongodb:Mongo.DriverBootstrap = MongoDB / [self.mongod] /?
         {
             $0.executors = .shared(threads)
             $0.appname = "Unidoc Preview"