Refactor ContentType + improve content type matching (#173)

Refactor ContentType + improve content type matching

### Motivation

The `ContentType` type had two issues:
- the enum where all cases had the same associated string value was not a good representation of the data
- the parsing was too strict and didn't match e.g. `foo/bar+json` as a JSON content type

### Modifications

Refactored `ContentType` to split the raw value storage from the `Category` (new term, ideas of a better name are welcome) of content types (`json`, `text`, or `binary`).

Also, improved the mapping to match https://json-schema.org/draft/2020-12/json-schema-core.html#section-4.2

### Result

Now the type is easier to work with, and parsing correctly recognizes `foo/bar+json` as JSON.

### Test Plan

Added unit tests.


Reviewed by: gjcairo, glbrntt

Builds:
     ✔︎ pull request validation (5.8) - Build finished. 
     ✔︎ pull request validation (5.9) - Build finished. 
     ✔︎ pull request validation (docc test) - Build finished. 
     ✔︎ pull request validation (integration test) - Build finished. 
     ✔︎ pull request validation (nightly) - Build finished. 
     ✔︎ pull request validation (soundness) - Build finished. 

#173

Author: czechboy0

Sources/_OpenAPIGeneratorCore/Translator/Content/ContentInspector.swift

@@ -162,30 +162,26 @@ extension FileTranslator {
             )
         }
         let chosenContent: (SchemaContent, OpenAPI.Content)?
-        if let (contentKey, contentValue) = map.first(where: { $0.key.isJSON }),
+        if let (contentKey, contentValue) = map.first(where: { $0.key.isJSON }) {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             chosenContent = (
                 .init(
                     contentType: contentType,
                     schema: contentValue.schema
                 ),
                 contentValue
             )
-        } else if let (contentKey, contentValue) = map.first(where: { $0.key.isText }),
+        } else if let (contentKey, contentValue) = map.first(where: { $0.key.isText }) {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             chosenContent = (
                 .init(
                     contentType: contentType,
                     schema: .b(.string)
                 ),
                 contentValue
             )
-        } else if !excludeBinary,
-            let (contentKey, contentValue) = map.first(where: { $0.key.isBinary }),
+        } else if !excludeBinary, let (contentKey, contentValue) = map.first(where: { $0.key.isBinary }) {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             chosenContent = (
                 .init(
                     contentType: contentType,
@@ -201,12 +197,14 @@ extension FileTranslator {
             chosenContent = nil
         }
         if let chosenContent {
-            let rawMIMEType = chosenContent.0.contentType.rawMIMEType
-            if rawMIMEType.hasPrefix("multipart/") || rawMIMEType.contains("application/x-www-form-urlencoded") {
+            let contentType = chosenContent.0.contentType
+            if contentType.lowercasedType == "multipart"
+                || contentType.lowercasedTypeAndSubtype.contains("application/x-www-form-urlencoded")
+            {
                 diagnostics.emitUnsupportedIfNotNil(
                     chosenContent.1.encoding,
                     "Custom encoding for JSON content",
-                    foundIn: "\(foundIn), content \(rawMIMEType)"
+                    foundIn: "\(foundIn), content \(contentType.originallyCasedTypeAndSubtype)"
                 )
             }
         }
@@ -234,9 +232,8 @@ extension FileTranslator {
         excludeBinary: Bool = false,
         foundIn: String
     ) -> SchemaContent? {
-        if contentKey.isJSON,
+        if contentKey.isJSON {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             diagnostics.emitUnsupportedIfNotNil(
                 contentValue.encoding,
                 "Custom encoding for JSON content",
@@ -247,18 +244,15 @@ extension FileTranslator {
                 schema: contentValue.schema
             )
         }
-        if contentKey.isText,
+        if contentKey.isText {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             return .init(
                 contentType: contentType,
                 schema: .b(.string)
             )
         }
-        if !excludeBinary,
-            contentKey.isBinary,
+        if !excludeBinary, contentKey.isBinary {
             let contentType = ContentType(contentKey.typeAndSubtype)
-        {
             return .init(
                 contentType: contentType,
                 schema: .b(.string(format: .binary))

Sources/_OpenAPIGeneratorCore/Translator/Content/ContentSwiftName.swift

@@ -21,7 +21,7 @@ extension FileTranslator {
     /// - Parameter contentType: The content type for which to compute the name.
     func contentSwiftName(_ contentType: ContentType) -> String {
         if config.featureFlags.contains(.multipleContentTypes) {
-            let rawMIMEType = contentType.rawMIMEType
+            let rawMIMEType = contentType.lowercasedTypeAndSubtype
             switch rawMIMEType {
             case "application/json":
                 return "json"
@@ -41,7 +41,7 @@ extension FileTranslator {
                 return swiftSafeName(for: rawMIMEType)
             }
         } else {
-            switch contentType {
+            switch contentType.category {
             case .json:
                 return "json"
             case .text:

Sources/_OpenAPIGeneratorCore/Translator/Content/ContentType.swift

@@ -17,103 +17,175 @@ import OpenAPIKit30
 ///
 /// Represents the serialization method of the payload and affects
 /// the generated serialization code.
-enum ContentType: Hashable {
+struct ContentType: Hashable {
 
-    /// A content type for JSON.
-    case json(String)
+    /// The category of a content type.
+    ///
+    /// This categorization helps the generator decide how to handle
+    /// the content's raw body data.
+    enum Category: Hashable {
+
+        /// A content type for JSON.
+        ///
+        /// The bytes are provided to a JSON encoder or decoder.
+        case json
+
+        /// A content type for any plain text.
+        ///
+        /// The bytes are encoded or decoded as a UTF-8 string.
+        case text
+
+        /// A content type for raw binary data.
+        ///
+        /// This case covers both explicit binary data content types, such
+        /// as `application/octet-stream`, and content types that no further
+        /// introspection is performed on, such as `image/png`.
+        ///
+        /// The bytes are not further processed, they are instead passed along
+        /// either to the network (requests) or to the caller (responses).
+        case binary
+
+        /// Creates a category from the provided type and subtype.
+        ///
+        /// First checks if the provided content type is a JSON, then text,
+        /// and uses binary if none of the two match.
+        /// - Parameters:
+        ///   - type: The first component of the MIME type.
+        ///   - subtype: The second component of the MIME type.
+        init(type: String, subtype: String) {
+            let lowercasedType = type.lowercased()
+            let lowercasedSubtype = subtype.lowercased()
+
+            // https://json-schema.org/draft/2020-12/json-schema-core.html#section-4.2
+            if (lowercasedType == "application" && lowercasedSubtype == "json") || lowercasedSubtype.hasSuffix("+json")
+            {
+                self = .json
+            } else if lowercasedType == "text" {
+                self = .text
+            } else {
+                self = .binary
+            }
+        }
 
-    /// A content type for any plain text.
-    case text(String)
+        /// The coding strategy appropriate for this content type.
+        var codingStrategy: CodingStrategy {
+            switch self {
+            case .json:
+                return .json
+            case .text:
+                return .text
+            case .binary:
+                return .binary
+            }
+        }
+    }
 
-    /// A content type for raw binary data.
-    case binary(String)
+    /// The mapped content type category.
+    var category: Category {
+        Category(type: type, subtype: subtype)
+    }
+
+    /// The first component of the MIME type.
+    private let type: String
+
+    /// The first component of the MIME type, as a lowercase string.
+    ///
+    /// The raw value in its original casing is only provided by `rawTypeAndSubtype`.
+    var lowercasedType: String {
+        type.lowercased()
+    }
+
+    /// The second component of the MIME type.
+    private let subtype: String
+
+    /// The second component of the MIME type, as a lowercase string.
+    ///
+    /// The raw value in its original casing is only provided by `originallyCasedTypeAndSubtype`.
+    var lowercasedSubtype: String {
+        subtype.lowercased()
+    }
 
     /// Creates a new content type by parsing the specified MIME type.
-    /// - Parameter rawValue: A MIME type, for example "application/json".
-    init?(_ rawValue: String) {
-        if rawValue.hasPrefix("application/") && rawValue.hasSuffix("json") {
-            self = .json(rawValue)
-            return
-        }
-        if rawValue.hasPrefix("text/") {
-            self = .text(rawValue)
-            return
-        }
-        self = .binary(rawValue)
+    /// - Parameter rawValue: A MIME type, for example "application/json". Must
+    ///   not be empty.
+    init(_ rawValue: String) {
+        precondition(!rawValue.isEmpty, "rawValue of a ContentType cannot be empty.")
+        let rawTypeAndSubtype =
+            rawValue
+            .split(separator: ";")[0]
+            .trimmingCharacters(in: .whitespaces)
+        let typeAndSubtype =
+            rawTypeAndSubtype
+            .split(separator: "/")
+            .map(String.init)
+        precondition(
+            typeAndSubtype.count == 2,
+            "Invalid ContentType string, must have 2 components separated by a slash."
+        )
+        self.type = typeAndSubtype[0]
+        self.subtype = typeAndSubtype[1]
     }
 
-    /// Returns the original raw MIME type.
-    var rawMIMEType: String {
-        switch self {
-        case .json(let string), .text(let string), .binary(let string):
-            return string
-        }
+    /// Returns the type and subtype as a "<type>/<subtype>" string.
+    ///
+    /// Respects the original casing provided as input.
+    var originallyCasedTypeAndSubtype: String {
+        "\(type)/\(subtype)"
+    }
+
+    /// Returns the type and subtype as a "<type>/<subtype>" string.
+    ///
+    /// Lowercased to ease case-insensitive comparisons.
+    var lowercasedTypeAndSubtype: String {
+        "\(lowercasedType)/\(lowercasedSubtype)"
     }
 
     /// The header value used when sending a content-type header.
     var headerValueForSending: String {
-        switch self {
-        case .json(let string):
-            // We always encode JSON using JSONEncoder which uses UTF-8.
-            return string + "; charset=utf-8"
-        case .text(let string):
-            return string
-        case .binary(let string):
-            return string
+        guard case .json = category else {
+            return lowercasedTypeAndSubtype
         }
+        // We always encode JSON using JSONEncoder which uses UTF-8.
+        return lowercasedTypeAndSubtype + "; charset=utf-8"
     }
 
     /// The header value used when validating a content-type header.
     ///
     /// This should be less strict, e.g. not require `charset`.
     var headerValueForValidation: String {
-        switch self {
-        case .json(let string):
-            return string
-        case .text(let string):
-            return string
-        case .binary(let string):
-            return string
-        }
+        lowercasedTypeAndSubtype
     }
 
     /// The coding strategy appropriate for this content type.
     var codingStrategy: CodingStrategy {
-        switch self {
-        case .json:
-            return .json
-        case .text:
-            return .text
-        case .binary:
-            return .binary
-        }
+        category.codingStrategy
     }
 
     /// A Boolean value that indicates whether the content type
     /// is a type of JSON.
     var isJSON: Bool {
-        if case .json = self {
-            return true
-        }
-        return false
+        category == .json
     }
 
     /// A Boolean value that indicates whether the content type
     /// is a type of plain text.
     var isText: Bool {
-        if case .text = self {
-            return true
-        }
-        return false
+        category == .text
     }
 
     /// A Boolean value that indicates whether the content type
     /// is just binary data.
     var isBinary: Bool {
-        if case .binary = self {
-            return true
-        }
-        return false
+        category == .binary
+    }
+
+    static func == (lhs: Self, rhs: Self) -> Bool {
+        // MIME type equality is case-insensitive.
+        lhs.lowercasedTypeAndSubtype == rhs.lowercasedTypeAndSubtype
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(lowercasedTypeAndSubtype)
     }
 }
 
@@ -122,27 +194,24 @@ extension OpenAPI.ContentType {
     /// A Boolean value that indicates whether the content type
     /// is a type of JSON.
     var isJSON: Bool {
-        guard let contentType = ContentType(typeAndSubtype) else {
-            return false
-        }
-        return contentType.isJSON
+        asGeneratorContentType.isJSON
     }
 
     /// A Boolean value that indicates whether the content type
     /// is a type of plain text.
     var isText: Bool {
-        guard let contentType = ContentType(typeAndSubtype) else {
-            return false
-        }
-        return contentType.isText
+        asGeneratorContentType.isText
     }
 
     /// A Boolean value that indicates whether the content type
     /// is just binary data.
     var isBinary: Bool {
-        guard let contentType = ContentType(typeAndSubtype) else {
-            return false
-        }
-        return contentType.isBinary
+        asGeneratorContentType.isBinary
+    }
+
+    /// Returns the content type wrapped in the generator's representation
+    /// of a content type, as opposed to the one from OpenAPIKit.
+    var asGeneratorContentType: ContentType {
+        ContentType(typeAndSubtype)
     }
 }