PR feedback

Author: czechboy0

Sources/_OpenAPIGeneratorCore/Config.swift

@@ -41,9 +41,7 @@ public struct Config: Sendable {
     public var filter: DocumentFilter?
 
     public var namingStrategy: NamingStrategy?
-    
     public var nameOverrides: [String: String]?
-    
     /// Additional pre-release features to enable.
     public var featureFlags: FeatureFlags
 
@@ -53,6 +51,8 @@ public struct Config: Sendable {
     ///   - access: The access modifier to use for generated declarations.
     ///   - additionalImports: Additional imports to add to each generated file.
     ///   - filter: Filter to apply to the OpenAPI document before generation.
+    ///   - namingStrategy: The OpenAPI -> Swift name conversion strategy.
+    ///   - nameOverrides: A map of OpenAPI -> Swift name overrides.
     ///   - featureFlags: Additional pre-release features to enable.
     public init(
         mode: GeneratorMode,

Sources/_OpenAPIGeneratorCore/Translator/CommonTranslations/SwiftSafeNames.swift

@@ -15,11 +15,8 @@ import Foundation
 
 struct SwiftNameOptions: OptionSet {
     let rawValue: Int32
-    
     static let none = SwiftNameOptions([])
-    
     static let capitalize = SwiftNameOptions(rawValue: 1 << 0)
-    
     static let all: SwiftNameOptions = [.capitalize]
 }
 
@@ -36,7 +33,7 @@ extension String {
     ///
     /// In addition to replacing illegal characters, it also
     /// ensures that the identifier starts with a letter and not a number.
-    func safeForSwiftCode_defensive(options: SwiftNameOptions) -> String {        
+    func safeForSwiftCode_defensive(options: SwiftNameOptions) -> String {
         guard !isEmpty else { return "_empty" }
 
         let firstCharSet: CharacterSet = .letters.union(.init(charactersIn: "_"))
@@ -84,10 +81,7 @@ extension String {
     /// matching `safeForSwiftCode_defensive`.
     func safeForSwiftCode_idiomatic(options: SwiftNameOptions) -> String {
         let capitalize = options.contains(.capitalize)
-        if isEmpty {
-            return capitalize ? "_Empty_" : "_empty_"
-        }
-        
+        if isEmpty { return capitalize ? "_Empty_" : "_empty_" }
         // Detect cases like HELLO_WORLD, sometimes used for constants.
         let isAllUppercase = allSatisfy {
             // Must check that no characters are lowercased, as non-letter characters
@@ -96,22 +90,24 @@ extension String {
         }
 
         // 1. Leave leading underscores as-are
-        // 2. In the middle: word separators: ["_", "-", <space>] -> remove and capitalize next word
-        // 3. In the middle: period: [".", "/"] -> replace with "_"
+        // 2. In the middle: word separators: ["_", "-", "/", <space>] -> remove and capitalize next word
+        // 3. In the middle: period: ["."] -> replace with "_"
         // 4. In the middle: drop ["{", "}"] -> replace with ""
-        
+
         var buffer: [Character] = []
         buffer.reserveCapacity(count)
-        
-        enum State {
+        enum State: Equatable {
             case modifying
-            case fallback
             case preFirstWord
+            struct AccumulatingFirstWordContext: Equatable { var isAccumulatingInitialUppercase: Bool }
+            case accumulatingFirstWord(AccumulatingFirstWordContext)
             case accumulatingWord
             case waitingForWordStarter
+            case fallback
         }
         var state: State = .preFirstWord
-        for char in self {
+        for index in self[...].indices {
+            let char = self[index]
             let _state = state
             state = .modifying
             switch _state {
@@ -124,30 +120,93 @@ extension String {
                     // Prefix with an underscore if the first character is a number.
                     buffer.append("_")
                     buffer.append(char)
-                    state = .accumulatingWord
+                    state = .accumulatingFirstWord(.init(isAccumulatingInitialUppercase: false))
                 } else if char.isLetter {
                     // First character in the identifier.
                     buffer.append(contentsOf: capitalize ? char.uppercased() : char.lowercased())
-                    state = .accumulatingWord
+                    state = .accumulatingFirstWord(
+                        .init(isAccumulatingInitialUppercase: !capitalize && char.isUppercase)
+                    )
                 } else {
                     // Illegal character, fall back to the defensive strategy.
                     state = .fallback
                 }
-            case .accumulatingWord:
+            case .accumulatingFirstWord(var context):
                 if char.isLetter || char.isNumber {
                     if isAllUppercase {
                         buffer.append(contentsOf: char.lowercased())
+                    } else if context.isAccumulatingInitialUppercase {
+                        // Example: "HTTPProxy"/"HTTP_Proxy"/"HTTP_proxy"" should all
+                        // become "httpProxy" when capitalize == false.
+                        // This means treating the first word differently.
+                        // Here we are on the second or later character of the first word (the first
+                        // character is handled in `.preFirstWord`.
+                        // If the first character was uppercase, and we're in lowercasing mode,
+                        // we need to lowercase every consequtive uppercase character while there's
+                        // another uppercase character after it.
+                        if char.isLowercase {
+                            // No accumulating anymore, just append it and turn off accumulation.
+                            buffer.append(char)
+                            context.isAccumulatingInitialUppercase = false
+                        } else {
+                            let suffix = suffix(from: self.index(after: index))
+                            if suffix.count >= 2 {
+                                let next = suffix.first!
+                                let secondNext = suffix.dropFirst().first!
+                                if next.isUppercase && secondNext.isLowercase {
+                                    // Finished lowercasing.
+                                    context.isAccumulatingInitialUppercase = false
+                                    buffer.append(contentsOf: char.lowercased())
+                                } else if Self.wordSeparators.contains(next) {
+                                    // Finished lowercasing.
+                                    context.isAccumulatingInitialUppercase = false
+                                    buffer.append(contentsOf: char.lowercased())
+                                } else if next.isUppercase {
+                                    // Keep lowercasing.
+                                    buffer.append(contentsOf: char.lowercased())
+                                } else {
+                                    // Append as-is, stop accumulating.
+                                    context.isAccumulatingInitialUppercase = false
+                                    buffer.append(char)
+                                }
+                            } else {
+                                // This is the last or second to last character,
+                                // since we were accumulating capitals, lowercase it.
+                                buffer.append(contentsOf: char.lowercased())
+                                context.isAccumulatingInitialUppercase = false
+                            }
+                        }
                     } else {
                         buffer.append(char)
                     }
+                    state = .accumulatingFirstWord(context)
+                } else if ["_", "-", " ", "/"].contains(char) {
+                    // In the middle of an identifier, these are considered
+                    // word separators, so we remove the character and end the current word.
+                    state = .waitingForWordStarter
+                } else if ["."].contains(char) {
+                    // In the middle of an identifier, these get replaced with
+                    // an underscore, but continue the current word.
+                    buffer.append("_")
+                    state = .accumulatingFirstWord(.init(isAccumulatingInitialUppercase: false))
+                } else if ["{", "}"].contains(char) {
+                    // In the middle of an identifier, curly braces are dropped.
+                    state = .accumulatingFirstWord(.init(isAccumulatingInitialUppercase: false))
+                } else {
+                    // Illegal character, fall back to the defensive strategy.
+                    state = .fallback
+                }
+            case .accumulatingWord:
+                if char.isLetter || char.isNumber {
+                    if isAllUppercase { buffer.append(contentsOf: char.lowercased()) } else { buffer.append(char) }
                     state = .accumulatingWord
-                } else if ["_", "-", " "].contains(char) {
-                    // In the middle of an identifier, dashes, underscores, and spaces are considered
+                } else if Self.wordSeparators.contains(char) {
+                    // In the middle of an identifier, these are considered
                     // word separators, so we remove the character and end the current word.
                     state = .waitingForWordStarter
-                } else if [".", "/"].contains(char) {
-                    // In the middle of an identifier, a period or a slash gets replaced with
-                    // an underscore, but continues the current word.
+                } else if ["."].contains(char) {
+                    // In the middle of an identifier, these get replaced with
+                    // an underscore, but continue the current word.
                     buffer.append("_")
                     state = .accumulatingWord
                 } else if ["{", "}"].contains(char) {
@@ -170,24 +229,18 @@ extension String {
                     // Illegal character, fall back to the defensive strategy.
                     state = .fallback
                 }
-            case .modifying, .fallback:
-                preconditionFailure("Logic error in \(#function), string: '\(self)'")
+            case .modifying, .fallback: preconditionFailure("Logic error in \(#function), string: '\(self)'")
             }
             precondition(state != .modifying, "Logic error in \(#function), string: '\(self)'")
-            if case .fallback = state {
-                return safeForSwiftCode_defensive(options: options)
-            }
-        }
-        if buffer.isEmpty || state == .preFirstWord {
-            return safeForSwiftCode_defensive(options: options)
+            if case .fallback = state { return safeForSwiftCode_defensive(options: options) }
         }
+        if buffer.isEmpty || state == .preFirstWord { return safeForSwiftCode_defensive(options: options) }
         // Check for keywords
         let newString = String(buffer)
-        if Self.keywords.contains(newString) {
-            return "_\(newString)"
-        }
+        if Self.keywords.contains(newString) { return "_\(newString)" }
         return newString
     }
+    private static let wordSeparators: Set<Character> = ["_", "-", " ", "/"]
 
     /// A list of Swift keywords.
     ///

Sources/_OpenAPIGeneratorCore/Translator/FileTranslator.swift

@@ -50,20 +50,14 @@ extension FileTranslator {
     var context: TranslatorContext {
         let asSwiftSafeName: (String, SwiftNameOptions) -> String
         switch config.namingStrategy {
-        case .defensive, .none:
-            asSwiftSafeName = { $0.safeForSwiftCode_defensive(options: $1) }
-        case .idiomatic:
-            asSwiftSafeName = { $0.safeForSwiftCode_idiomatic(options: $1) }
+        case .defensive, .none: asSwiftSafeName = { $0.safeForSwiftCode_defensive(options: $1) }
+        case .idiomatic: asSwiftSafeName = { $0.safeForSwiftCode_idiomatic(options: $1) }
         }
         let overrides = config.nameOverrides ?? [:]
-        return TranslatorContext(
-            asSwiftSafeName: { name, options in
-                if let override = overrides[name] {
-                    return override
-                }
-                return asSwiftSafeName(name, options)
-            }
-        )
+        return TranslatorContext(asSwiftSafeName: { name, options in
+            if let override = overrides[name] { return override }
+            return asSwiftSafeName(name, options)
+        })
     }
 }
 

Sources/_OpenAPIGeneratorCore/Translator/Multipart/MultipartContentInspector.swift

@@ -305,7 +305,7 @@ extension FileTranslator {
             return nil
         }
         let finalContentTypeSource: MultipartPartInfo.ContentTypeSource
-        if let encoding, let contentType = encoding.contentType {
+        if let contentTypes = encoding?.contentTypes, let contentType = contentTypes.first, contentTypes.count == 1 {
             finalContentTypeSource = try .explicit(contentType.asGeneratorContentType)
         } else {
             finalContentTypeSource = candidateSource

Sources/_OpenAPIGeneratorCore/Translator/TypeAssignment/TypeAssigner.swift

@@ -495,7 +495,8 @@ struct TypeAssigner {
     {
         typeNameForComponents()
             .appending(
-                swiftComponent: context.asSwiftSafeName(componentType.openAPIComponentsKey, .capitalize).uppercasingFirstLetter,
+                swiftComponent: context.asSwiftSafeName(componentType.openAPIComponentsKey, .capitalize)
+                    .uppercasingFirstLetter,
                 jsonComponent: componentType.openAPIComponentsKey
             )
     }

Sources/swift-openapi-generator/Extensions.swift

@@ -18,9 +18,14 @@ import Yams
 
 #if $RetroactiveAttribute
 extension URL: @retroactive ExpressibleByArgument {}
+#if compiler(<6.0)
 extension GeneratorMode: @retroactive ExpressibleByArgument {}
 extension FeatureFlag: @retroactive ExpressibleByArgument {}
 #else
+extension GeneratorMode: ExpressibleByArgument {}
+extension FeatureFlag: ExpressibleByArgument {}
+#endif
+#else
 extension URL: ExpressibleByArgument {}
 extension GeneratorMode: ExpressibleByArgument {}
 extension FeatureFlag: ExpressibleByArgument {}

Sources/swift-openapi-generator/FilterCommand.swift

@@ -81,20 +81,15 @@ private func timing<Output>(_ title: String, _ operation: @autoclosure () throws
 }
 
 private let sampleConfig = _UserConfig(
-    generate: [
-        .types,
-        .client
-    ],
+    generate: [.types, .client],
     filter: DocumentFilter(
         operations: ["getGreeting"],
         tags: ["greetings"],
         paths: ["/greeting"],
         schemas: ["Greeting"]
     ),
     namingStrategy: .idiomatic,
-    nameOverrides: [
-        "SPECIAL_NAME": "SpecialName"
-    ]
+    nameOverrides: ["SPECIAL_NAME": "SpecialName"]
 )
 
 enum OutputFormat: String, ExpressibleByArgument {

Sources/swift-openapi-generator/GenerateOptions.swift

@@ -75,14 +75,8 @@ extension _GenerateOptions {
         return []
     }
 
-    func resolvedNamingStrategy(_ config: _UserConfig?) -> NamingStrategy {
-        config?.namingStrategy ?? .defensive
-    }
-    
-    func resolvedNameOverrides(_ config: _UserConfig?) -> [String: String] {
-        config?.nameOverrides ?? [:]
-    }
-    
+    func resolvedNamingStrategy(_ config: _UserConfig?) -> NamingStrategy { config?.namingStrategy ?? .defensive }
+    func resolvedNameOverrides(_ config: _UserConfig?) -> [String: String] { config?.nameOverrides ?? [:] }
     /// Returns a list of the feature flags requested by the user.
     /// - Parameter config: The configuration specified by the user.
     /// - Returns: A set of feature flags requested by the user.

Sources/swift-openapi-generator/UserConfig.swift

@@ -37,7 +37,7 @@ struct _UserConfig: Codable {
     var namingStrategy: NamingStrategy?
 
     /// A dictionary of name overrides for generated types and members.
-    /// 
+    ///
     /// Any names not included use the `namingStrategy` to compute a Swift name.
     var nameOverrides: [String: String]?