Fix #17 Encoding optionals

Author: dehesa

README.md

@@ -649,18 +649,13 @@ To configure the encoding/decoding process, you need to set the configuration va
     decoder.decode([Pets].self, from: url2)
     ```
 
-The strategies labeled with `.custom` let you insert behavior into the encoding/decoding process without forcing you to manually conform to `init(from:)` and `encode(to:)`. When set, they will reference the targeted type for the whole process. For example, if you want to decode a CSV file where empty fields are marked with the word `null` (for some reason). You could do the following:
+The strategies labeled with `.custom` let you insert behavior into the encoding/decoding process without forcing you to manually conform to `init(from:)` and `encode(to:)`. When set, they will reference the targeted type for the whole process. For example, if you want to encode a CSV file where empty fields are marked with the word `null` (for some reason). You could do the following:
 
 ```swift
 let decoder = CSVDecoder()
-decoder.nilStrategy = .custom({ (decoder) -> Bool in
-    do {
-        let container = try decoder.singleValueContainer()
-        let field = try container.decode(String.self)
-        return field == "null"
-    } catch let error {
-        return false
-    }
+decoder.nilStrategy = .custom({ (encoder) in
+    var container = encoder.singleValueContainer()
+    try container.encode("null")
 })
 ```
 
@@ -692,6 +687,6 @@ If `CodableCSV` is not of your liking, the Swift community has developed other C
 -   [SwiftCSVExport](https://github.com/vigneshuvi/SwiftCSVExport) reads/writes CSV imperatively with Objective-C support.
 -   [swift-csv](https://github.com/brutella/swift-csv) offers an imperative CSV reader/writer based on Foundation's streams.
 -   [CSV](https://github.com/skelpo/CSV) offers synchronous and asynchronous imperative CSV reader/writer and encoders/decoders.
--   [CommonCoding](https://github.com/Lantua/CommonCoding) provides CSV encoder/decoder conforming to the [RFC4180](https://tools.ietf.org/html/rfc4180) standard.
+-   [CommonCoding](https://github.com/Lantua/CommonCoding) provides a CSV encoder/decoder conforming to the [RFC4180](https://tools.ietf.org/html/rfc4180) standard.
 
 There are many good tools outside the Swift community. Since writing them all would be a hard task, I will just point you to the great [AwesomeCSV](https://github.com/secretGeek/awesomeCSV) github repo. Take it a look! There are a lot of treasures to be found there.

sources/declarative/encodable/containers/KeyedEncodingContainer.swift

@@ -192,67 +192,97 @@ extension ShadowEncoder.KeyedContainer {
 //    }
 }
 
-//extension ShadowEncoder.KeyedContainer {
-//    mutating func encodeIfPresent(_ value: String?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Bool?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Double?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Float?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Int?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Int8?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Int16?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Int32?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: Int64?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: UInt?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws {
-//        fatalError()
-//    }
-//
-//    mutating func encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T:Encodable {
-//        fatalError()
-//    }
-//}
+extension ShadowEncoder.KeyedContainer {
+    mutating func encodeIfPresent(_ value: String?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Bool?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Double?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Float?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Int?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Int8?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Int16?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Int32?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: Int64?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: UInt?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: UInt8?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: UInt16?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: UInt32?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent(_ value: UInt64?, forKey key: Key) throws {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+
+    mutating func encodeIfPresent<T>(_ value: T?, forKey key: Key) throws where T:Encodable {
+        var container = try self.fieldContainer(forKey: key)
+        guard let value = value else { return try container.encodeNil() }
+        try container.encode(value)
+    }
+}
 
 // MARK: -
 

sources/imperative/writer/Writer.swift

@@ -187,59 +187,51 @@ extension CSVWriter {
     /// - parameter field: The field to be checked for characters to escape and subsequently written.
     /// - throws: `CSVError<CSVWriter>` exclusively.
     private func lowlevelWrite(field: String) throws {
-        var result: [Unicode.Scalar]
+        // 1. If the field is empty, don't write anything.
+        guard !field.isEmpty else { return }
 
-        // 1. If the field is empty, just write two escaping scalars.
-        if field.isEmpty {
-            switch self.settings.escapingScalar {
-            case let s?: result = .init(repeating: s, count: 2)
-            case .none:  result = .init()
+        let input:  [Unicode.Scalar] = .init(field.unicodeScalars)
+        // 2. Reserve space for all field scalars plus a bit more in case escaping is needed.
+        var result: [Unicode.Scalar] = .init()
+        result.reserveCapacity(input.count + 3)
+        
+        // 3.A. If escaping is allowed.
+        if let escapingScalar = self.settings.escapingScalar {
+            var (index, needsEscaping) = (0, false)
+            // 4. Iterate through all the input's Unicode scalars.
+            while index < input.endIndex {
+                let scalar = input[index]
+                // 5. If the escaping character appears, the field needs escaping, but also the escaping character is duplicated.
+                if scalar == escapingScalar {
+                    needsEscaping = true
+                    result.append(escapingScalar)
+                // 6. If there is a field or row delimiter, the field needs escaping.
+                } else if self.isFieldDelimiter(input, &index, &result) || self.isRowDelimiter(input, &index, &result) {
+                    needsEscaping = true
+                    continue
+                }
+                
+                result.append(scalar)
+                index += 1
             }
-        // 2. If the field contains characters...
-        } else {
-            let input: [Unicode.Scalar] = .init(field.unicodeScalars)
-            result = .init()
-            // 3. Reserve space for all field scalars plus a bit more in case escaping is needed.
-            result.reserveCapacity(input.count + 3)
 
-            // 4.A. If escaping is allowed.
-            if let escapingScalar = self.settings.escapingScalar {
-                var (index, needsEscaping) = (0, false)
-                // 5. Iterate through all the input's Unicode scalars.
-                while index < input.endIndex {
-                    let scalar = input[index]
-                    // 6. If the escaping character appears, the field needs escaping, but also the escaping character is duplicated.
-                    if scalar == escapingScalar {
-                        needsEscaping = true
-                        result.append(escapingScalar)
-                    // 7. If there is a field or row delimiter, the field needs escaping.
-                    } else if self.isFieldDelimiter(input, &index, &result) || self.isRowDelimiter(input, &index, &result) {
-                        needsEscaping = true
-                        continue
-                    }
-                    
-                    result.append(scalar)
-                    index += 1
+            // 7. If the field needed escaping, insert the escaping escalar at the beginning and end of the field.
+            if needsEscaping {
+                result.insert(escapingScalar, at: result.startIndex)
+                result.append(escapingScalar)
+            }
+        // 3.B. If escaping is not allowed.
+        } else {
+            var index = 0
+            // 4. Iterate through all the input's Unicode scalars.
+            while index < input.endIndex {
+                // 5. If the input data contains a delimiter, throw an error.
+                guard !self.isFieldDelimiter(input, &index, &result), !self.isRowDelimiter(input, &index, &result) else {
+                    throw Error.invalidPriviledgeCharacter(on: field)
                 }
 
-                // 8. If the field needed escaping, insert the escaping escalar at the beginning and end of the field.
-                if needsEscaping {
-                    result.insert(escapingScalar, at: result.startIndex)
-                    result.append(escapingScalar)
-                }
-            // 4.B. If escaping is not allowed.
-            } else {
-                var index = 0
-                // 5. Iterate through all the input's Unicode scalars.
-                while index < input.endIndex {
-                    // 6. If the input data contains a delimiter, through an error.
-                    guard !self.isFieldDelimiter(input, &index, &result), !self.isRowDelimiter(input, &index, &result) else {
-                        throw Error.invalidPriviledgeCharacter(on: field)
-                    }
-                    
-                    result.append(input[index])
-                    index += 1
-                }
+                result.append(input[index])
+                index += 1
             }
         }
 

tests/CodableTests/EncodingOptionalsTests.swift

@@ -0,0 +1,82 @@
+import XCTest
+import CodableCSV
+
+/// Tests checking the regular encoding usage.
+final class EncodingOptionalsTests: XCTestCase {
+    override func setUp() {
+        self.continueAfterFailure = false
+    }
+}
+
+extension EncodingOptionalsTests {
+    /// Tests writting `nil` values on a keyed containers with named coding keys.
+    func testOptionalNamedFields() throws {
+        struct Student: Encodable {
+            let name: String, age: Int?, country: String?, hasPet: Bool?
+        }
+        
+        let students: [Student] = [
+            .init(name: "Marcos", age: 1, country: "Spain", hasPet: true),
+            .init(name: "Anaïs",  age: nil, country: "France", hasPet: false),
+            .init(name: "Alex",   age: 3, country: nil, hasPet: false),
+            .init(name: "家豪",    age: nil, country: "China", hasPet: nil),
+            .init(name: "Дэниел", age: 5, country: nil, hasPet: nil),
+            .init(name: "ももこ",  age: nil, country: nil, hasPet: nil)
+        ]
+        
+        let encoder = CSVEncoder { $0.headers = ["name", "age", "country", "hasPet"] }
+        let result = try encoder.encode(students, into: String.self)
+        XCTAssertFalse(result.isEmpty)
+    }
+    
+    /// Tests writting `nil` values on a keyed containers with integer coding keys.
+    func testOptionalIntegerFields() throws {
+        struct Student: Encodable {
+            let name: String, age: Int?, country: String?, hasPet: Bool?
+            private enum CodingKeys: Int, CodingKey {
+                case name=0, age, country, hasPet
+            }
+        }
+        
+        let students: [Student] = [
+            .init(name: "Marcos", age: 1, country: "Spain", hasPet: true),
+            .init(name: "Anaïs",  age: nil, country: "France", hasPet: false),
+            .init(name: "Alex",   age: 3, country: nil, hasPet: false),
+            .init(name: "家豪",    age: nil, country: "China", hasPet: nil),
+            .init(name: "Дэниел", age: 5, country: nil, hasPet: nil),
+            .init(name: "ももこ",  age: nil, country: nil, hasPet: nil)
+        ]
+        
+        let encoder = CSVEncoder()
+        let result = try encoder.encode(students, into: String.self)
+        XCTAssertFalse(result.isEmpty)
+        XCTAssertTrue(result.hasPrefix("Marcos,1,Spain,true\nAnaïs,,France,false"))
+    }
+    
+    /// Tests writting `nil` values on a keyed containers with named coding keys.
+    func testOptionalNamedFieldsWithCustomStrategy() throws {
+        struct Student: Encodable {
+            let name: String, age: Int?, country: String?, hasPet: Bool?
+        }
+        
+        let students: [Student] = [
+            .init(name: "Marcos", age: 1, country: "Spain", hasPet: true),
+            .init(name: "Anaïs",  age: nil, country: "France", hasPet: false),
+            .init(name: "Alex",   age: 3, country: nil, hasPet: false),
+            .init(name: "家豪",    age: nil, country: "China", hasPet: nil),
+            .init(name: "Дэниел", age: 5, country: nil, hasPet: nil),
+            .init(name: "ももこ",  age: nil, country: nil, hasPet: nil)
+        ]
+        
+        let encoder = CSVEncoder {
+            $0.headers = ["name", "age", "country", "hasPet"]
+            $0.nilStrategy = .custom({
+                var container = $0.singleValueContainer()
+                try container.encode("null")
+            })
+        }
+        let result = try encoder.encode(students, into: String.self)
+        XCTAssertFalse(result.isEmpty)
+        XCTAssertTrue(result.contains("null"))
+    }
+}

tests/CodableTests/EncodingRegularUsageTests.swift

@@ -118,7 +118,7 @@ extension EncodingRegularUsageTests {
             let encoder = CSVEncoder(configuration: configuration)
             let data = try encoder.encode(value)
             let string = String(data: data, encoding: encoding)!
-            XCTAssertEqual(string, "\"\"\(delimiters.row.rawValue)")
+            XCTAssertEqual(string, "\(delimiters.row.rawValue)")
         }
     }