Merge branch 'develop' into main

Author: helje5

Package.swift

@@ -12,9 +12,9 @@ let package = Package(
 
   dependencies: [
     .package(url: "https://github.com/Macro-swift/Macro.git",
-             from: "0.6.0"),
+             from: "0.6.2"),
     .package(url: "https://github.com/Macro-swift/MacroExpress.git",
-             from: "0.5.7"),
+             from: "0.6.0"),
     .package(url: "https://github.com/AlwaysRightInstitute/SwiftXmlRpc.git",
              from: "0.8.5")
   ],

Sources/MacroXmlRpc/BodyParser.swift

@@ -36,10 +36,9 @@ public extension bodyParser {
    * This plays well w/ other body parsers. If no other parser was active,
    * it will fill `request.body` as `.text`.
    */
-  @inlinable
   static func xmlRpcCall() -> Middleware {
     return { req, res, next in
-      if req.extra[xmlRpcRequestKey] != nil { return next() } // parsed already
+      if req[XmlRpcBodyKey.self] != nil { return next() } // parsed already
 
       func registerCallInLogger() {
         guard let call = req.xmlRpcCall else { return }
@@ -104,25 +103,22 @@ public extension bodyParser {
       }
     }
   }
-
 }
 
-@usableFromInline
-let xmlRpcRequestKey = "macro.xmlrpc.body-parser"
+internal enum XmlRpcBodyKey: EnvironmentKey {
+  static let defaultValue : bodyParser.XmlRpcBodyParserBody? = nil
+  static let loggingKey   = "xmlrpc.body"
+}
 
 public extension IncomingMessage {
 
   /**
    * Returns the XML-RPC body parsed by e.g. `bodyParser.xmlRpcCall`. It is
    * only filled when the middleware executed, otherwise it returns `.invalid`.
    */
-  @inlinable
   var xmlRpcBody: bodyParser.XmlRpcBodyParserBody {
-    set { extra[xmlRpcRequestKey] = newValue }
-    get {
-      return (extra[xmlRpcRequestKey] as? bodyParser.XmlRpcBodyParserBody)
-          ?? .invalid
-    }
+    set { environment[XmlRpcBodyKey.self] = newValue }
+    get { return environment[XmlRpcBodyKey.self] ?? .invalid }
   }
 
   /**

Sources/MacroXmlRpc/Introspection.swift

@@ -148,59 +148,49 @@ fileprivate extension IncomingMessage {
   }
 }
 
-@usableFromInline
-let xmlRpcMethodsRequestKey          = "macro.xmlrpc.method-names"
-@usableFromInline
-let xmlRpcHelpsRequestKey            = "macro.xmlrpc.method-helps"
-@usableFromInline
-let xmlRpcMethodSignaturesRequestKey = "macro.xmlrpc.method-signatures"
+private enum MethodNames: EnvironmentKey {
+  static let defaultValue : Set<String> = []
+  static let loggingKey   = "xmlrpc.names"
+}
+private enum MethodHelps: EnvironmentKey {
+  static let defaultValue : [ String : String ] = [:]
+  static let loggingKey   = "xmlrpc.helps"
+}
+private enum MethodSignatures: EnvironmentKey {
+  static let defaultValue : [ String : [ [ XmlRpc.Value.ValueType ] ] ] = [:]
+  static let loggingKey   = "xmlrpc.signatues"
+}
 
 extension IncomingMessage {
 
   fileprivate var knownXmlRpcMethodNames : Set<String> {
-    return (extra[xmlRpcMethodsRequestKey] as? Set<String>) ?? []
+    return environment[MethodNames.self]
   }
 
   @usableFromInline
   func addKnownXmlRpcMethod(_ methodName: String) {
-    if var methods = extra.removeValue(forKey: xmlRpcMethodsRequestKey)
-                 as? Set<String>
-    {
-      methods.insert(methodName)
-      extra[xmlRpcMethodsRequestKey] = methods
-    }
-    else {
-      extra[xmlRpcMethodsRequestKey] = Set([ methodName ])
-    }
+    environment[MethodNames.self].insert(methodName)
   }
 
   @usableFromInline
-  func addHelp(_ help: String, for method: String) {
-    var helps = extra.removeValue(forKey: xmlRpcHelpsRequestKey)
-                as? [ String : String ]
-             ?? [:]
-    helps[method] = help
-    extra[xmlRpcHelpsRequestKey] = helps
+  func addHelp(_ help: String, for methodName: String) {
+    environment[MethodHelps.self][methodName] = help
   }
 
   @usableFromInline
   func addSignature(_ signature: [ XmlRpc.Value.ValueType ],
                     for method: String)
   {
-    var values = extra.removeValue(forKey: xmlRpcMethodSignaturesRequestKey)
-             as? [ String : [ [ XmlRpc.Value.ValueType ] ] ]
-              ?? [:]
+    var values = environment[MethodSignatures.self]
     values[method, default: []].append(signature)
-    extra[xmlRpcMethodSignaturesRequestKey] = values
+    environment[MethodSignatures.self] = values
   }
 
   fileprivate var helps : [ String : String ] {
-    return (extra[xmlRpcHelpsRequestKey] as? [ String : String ]) ?? [:]
+    return environment[MethodHelps.self]
   }
   fileprivate var signatures : [ String : [ [ XmlRpc.Value.ValueType ] ] ] {
-    return (extra[xmlRpcMethodSignaturesRequestKey]
-                as? [ String : [ [ XmlRpc.Value.ValueType ] ] ])
-        ?? [:]
+    return environment[MethodSignatures.self]
   }
 }
 

Sources/MacroXmlRpc/Middleware.swift

@@ -67,16 +67,15 @@ public extension xmlrpc {
           return res.send("Call to XML-RPC function failed.")
         }
       }
-
+      
       /* Body parser is not active */
-      if req.extra[xmlRpcRequestKey] == nil,
-         typeIs(req, [ "text/xml" ]) != nil
-      {
+      if req.environment[XmlRpcBodyKey.self] == nil, req.is("text/xml") {
         req.log.notice("Use of XML-RPC middleware w/o a bodyParser")
         let parser = bodyParser.xmlRpcCall()
         do {
           try parser(req, res) { (args: Any...) in
-            assert(req.extra[xmlRpcRequestKey] != nil) // at least .invalid!
+            assert(req.environment[XmlRpcBodyKey.self] != nil)
+              // at least .invalid!
             process()
           }
         }