Add support for underscore notation

Author: Jakob Mygind

Model Boiler/Classes/Helpers/CodableGenerator.swift

@@ -13,9 +13,11 @@ import SwiftSemantics
 class Generator {
 
     let source: String
+    let mapUnderscoreToCamelCase: Bool
 
-    init(source: String) {
+    init(source: String, mapUnderscoreToCamelCase: Bool = false) {
         self.source = source
+        self.mapUnderscoreToCamelCase = mapUnderscoreToCamelCase
     }
 
     var encode: [String] = ["""
@@ -35,17 +37,43 @@ class Generator {
             """
     ]
 
-    func addNode(name: String, type: String, isOptional: Bool = false) {
+   func addNode(name: String, type: String, isOptional: Bool = false) {
         encode.append("    try container.encode(\(name), forKey: .\(name))")
         if isOptional {
             initStrings.append("    \(name) = try container.decodeIfPresent(\(type.trimmingCharacters(in: .init(charactersIn: "?"))).self, forKey: .\(name))")
         } else {
             initStrings.append("    \(name) = try container.decode(\(type).self, forKey: .\(name))")
         }
-        codingKeys.append("    case \(name) = \"\(name)\"")
+       
+        if mapUnderscoreToCamelCase {
+             codingKeys.append("    case \(name) = \"\(mapCamelToUnderscore(name))\"")
+        } else {
+             codingKeys.append("    case \(name) = \"\(name)\"")
+        }
+    }
+    
+    func mapCamelToUnderscore(_ string: String) -> String {
+        var res = ""
+
+        var strCopy = string[...]
+        while let match = parseWord(str: &strCopy) {
+            res += "_" + match.lowercased()
+        }
+        return res.trimmingCharacters(in: CharacterSet.init(charactersIn: "_"))
     }
 
-   /// Generation is based on dumb pattern matchint
+    func parseWord(str: inout Substring) -> String? {
+        
+        if let lowerMatch = Parser.lower.run(&str) {
+            return lowerMatch
+        }
+        if let upperThenLower = zip(Parser.upper, Parser.lower).run(&str) {
+            return upperThenLower.0 + upperThenLower.1
+        }
+        return Parser.upper.run(&str)
+    }
+    
+    /// Generation is based on dumb pattern matchint
       func generate() throws -> String {
           var collector = DeclarationCollector()
           let tree = try SyntaxParser.parse(source: source)
@@ -82,3 +110,37 @@ class Generator {
       }
 }
 
+struct Parser<A> {
+    let run: (inout Substring) -> A?
+}
+
+extension Parser where A == String {
+    
+    static func predicate(_ predicate: @escaping (Character) -> Bool) -> Parser {
+        Parser { str in
+            let match = str.prefix(while: predicate)
+            guard !match.isEmpty else { return nil }
+            str.removeFirst(match.count)
+            return String(match)
+        }
+    }
+    
+    static let upper: Parser = .predicate { $0.isUppercase }
+    
+    static let lower: Parser = .predicate { $0.isLowercase }
+}
+
+func zip<A, B>(_ pa: Parser<A>, _ pb: Parser<B>) -> Parser<(A, B)> {
+    Parser { str in
+        let originalString = str
+        guard let a = pa.run(&str) else {
+            return nil
+        }
+        guard let b = pb.run(&str) else {
+            str = originalString
+            return nil
+        }
+        return (a, b)
+    }
+}
+

Model Boiler/Classes/Service/Service.swift

@@ -35,7 +35,7 @@ struct Service {
 //        
         do {
             // Try to generate the code
-            let code = try Generator(source: source).generate()
+            let code = try Generator(source: source, mapUnderscoreToCamelCase: !SettingsManager.isSettingEnabled(.NoCamelCaseConversion)).generate()
 
             // Play success sound
             playSound(Service.successSound)

ModelBoilerTests/ModelBoilerTests.swift

@@ -150,4 +150,48 @@ class ModelBoilerTests: XCTestCase {
         let res = try XCTUnwrap(try Generator(source: str).generate())
         XCTAssertEqual(res, expected)
     }
+    
+    func testCamelCaseToUnderscore() throws {
+        
+        let str = """
+        struct Test {
+            var intVal = 1
+            var doubleVal = 2.33
+            var stringVal = "Hello"
+            var boolVal = true
+            var imageURL: URL
+        }
+        """
+        
+        let expected = """
+        enum CodingKeys: String, CodingKey {
+            case intVal = "int_val"
+            case doubleVal = "double_val"
+            case stringVal = "string_val"
+            case boolVal = "bool_val"
+            case imageURL = "image_url"
+        }
+
+        public func encode(to encoder: Encoder) throws {
+            var container = encoder.container(keyedBy: CodingKeys.self)
+            try container.encode(intVal, forKey: .intVal)
+            try container.encode(doubleVal, forKey: .doubleVal)
+            try container.encode(stringVal, forKey: .stringVal)
+            try container.encode(boolVal, forKey: .boolVal)
+            try container.encode(imageURL, forKey: .imageURL)
+        }
+
+        public init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            intVal = try container.decode(Int.self, forKey: .intVal)
+            doubleVal = try container.decode(Double.self, forKey: .doubleVal)
+            stringVal = try container.decode(String.self, forKey: .stringVal)
+            boolVal = try container.decode(Bool.self, forKey: .boolVal)
+            imageURL = try container.decode(URL.self, forKey: .imageURL)
+        }
+        """
+        
+        let res = try XCTUnwrap(try Generator(source: str, mapUnderscoreToCamelCase: true).generate())
+               XCTAssertEqual(res, expected)
+    }
 }