Transform most errors to CSVError

Author: dehesa

sources/Delimiter.swift

@@ -34,7 +34,7 @@ extension Delimiter {
 }
 
 extension Delimiter {
-    /// The separator to use between rows.
+    /// The delimiter between rows.
     public struct Row: ExpressibleByNilLiteral, ExpressibleByStringLiteral, RawRepresentable {
         public let rawValue: String.UnicodeScalarView
 

sources/Utils.swift

@@ -46,15 +46,15 @@ internal extension DateFormatter {
     }()
 }
 
-infix operator ?!
+infix operator ?>
 
 internal extension Optional {
     /// Checks whether the value exists. If so, it returns the value; if not, it throws the given error.
     /// - parameter lhs: Optional value to check for existance.
     /// - parameter rhs: Swift error to throw in case of no value.
     /// - returns: The value (non-optional) passed as parameter.
     /// - throws: The Swift error returned on the right hand-side autoclosure.
-    @_transparent static func ?!(lhs: Self, rhs: @autoclosure ()->Swift.Error) throws -> Wrapped {
+    @_transparent static func ?>(lhs: Self, rhs: @autoclosure ()->Swift.Error) throws -> Wrapped {
         switch lhs {
         case .some(let v): return v
         case .none: throw rhs()

sources/declarative/decodable/Decoder.swift

@@ -34,7 +34,6 @@ extension CSVDecoder {
     /// Returns a value of the type you specify, decoded from a CSV file (given as a `Data` blob).
     /// - parameter type: The type of the value to decode from the supplied file.
     /// - parameter data: The data blob representing a CSV file.
-    /// - throws: `DecodingError`, or `CSVError<CSVReader>`, or the error raised by your custom types.
     open func decode<T:Decodable>(_ type: T.Type, from data: Data) throws -> T {
         let reader = try CSVReader(input: data, configuration: self._configuration.readerConfiguration)
         let source = ShadowDecoder.Source(reader: reader, configuration: self._configuration, userInfo: self.userInfo)
@@ -44,22 +43,29 @@ extension CSVDecoder {
     /// Returns a value of the type you specify, decoded from a CSV file (given as a `String`).
     /// - parameter type: The type of the value to decode from the supplied file.
     /// - parameter string: A Swift string representing a CSV file.
-    /// - throws: `DecodingError`, or `CSVError<CSVReader>`, or the error raised by your custom types.
     open func decode<T:Decodable>(_ type: T.Type, from string: String) throws -> T {
         let reader = try CSVReader(input: string, configuration: self._configuration.readerConfiguration)
         let source = ShadowDecoder.Source(reader: reader, configuration: self._configuration, userInfo: self.userInfo)
         return try T(from: ShadowDecoder(source: source, codingPath: []))
     }
 
-    /// Returns a value of the type you specify, decoded from a CSV file (being pointed by `url`).
+    /// Returns a value of the type you specify, decoded from a CSV file (being pointed by the url).
     /// - parameter type: The type of the value to decode from the supplied file.
     /// - parameter url: The URL pointing to the file to decode.
-    /// - throws: `DecodingError`, or `CSVError<CSVReader>`, or the error raised by your custom types.
     open func decode<T:Decodable>(_ type: T.Type, from url: URL) throws -> T {
         let reader = try CSVReader(input: url, configuration: self._configuration.readerConfiguration)
         let source = ShadowDecoder.Source(reader: reader, configuration: self._configuration, userInfo: self.userInfo)
         return try T(from: ShadowDecoder(source: source, codingPath: []))
     }
+    
+    /// Returns a value of the type you specify, decoded from a CSV file (provided by the input stream).
+    /// - parameter type: The type of the value to decode from the supplied file.
+    /// - parameter stream: The input stream providing the raw bytes.
+    open func decode<T:Decodable>(_ type: T.Type, from stream: InputStream) throws -> T {
+        let reader = try CSVReader(input: stream, configuration: self._configuration.readerConfiguration)
+        let source = ShadowDecoder.Source(reader: reader, configuration: self._configuration, userInfo: self.userInfo)
+        return try T(from: ShadowDecoder(source: source, codingPath: []))
+    }
 }
 
 extension CSVDecoder {

sources/declarative/decodable/DecoderConfiguration.swift

@@ -4,7 +4,7 @@ extension CSVDecoder {
     /// Configuration for how to read CSV data.
     @dynamicMemberLookup public struct Configuration {
         /// The underlying `CSVReader` configurations.
-        @usableFromInline private(set) internal var readerConfiguration: CSVReader.Configuration
+        @usableFromInline internal private(set) var readerConfiguration: CSVReader.Configuration
         /// The strategy to use when decoding a `nil` representation.
         public var nilStrategy: Strategy.NilDecoding
         /// The strategy to use when decoding Boolean values.
@@ -41,8 +41,6 @@ extension CSVDecoder {
     }
 }
 
-// MARK: -
-
 extension Strategy {
     /// The strategy to use for decoding `nil` representations.
     public enum NilDecoding {
@@ -149,3 +147,29 @@ extension Strategy {
         case sequential
     }
 }
+
+// MARK: -
+
+extension CSVDecoder: Failable {
+    /// The type of error raised by the CSV decoder.
+    public enum Error: Int {
+        /// Some of the configuration values provided are invalid.
+        case invalidConfiguration = 1
+        /// The decoding coding path is invalid.
+        case invalidPath = 2
+        /// An error occurred on the encoder buffer.
+        case bufferFailure = 4
+    }
+    
+    public static var errorDomain: String {
+        "Decoder"
+    }
+    
+    public static func errorDescription(for failure: Error) -> String {
+        switch failure {
+        case .invalidConfiguration: return "Invalid configuration"
+        case .invalidPath: return "Invalid path"
+        case .bufferFailure: return "Invalid buffer state"
+        }
+    }
+}

sources/declarative/decodable/DecoderLazy.swift

@@ -38,7 +38,6 @@ extension CSVDecoder.LazySequence {
 
         /// Returns a value of the type you specify, decoded from CSV row.
         /// - parameter type: The type of the value to decode from the supplied file.
-        /// - throws: `DecodingError`, or `CSVError<CSVReader>`, or the error raised by your custom types.
         @inline(__always) public func decode<T:Decodable>(_ type: T.Type) throws -> T {
             return try T(from: self._decoder)
         }

sources/declarative/decodable/containers/KeyedDecodingContainer.swift

@@ -30,10 +30,10 @@ extension ShadowDecoder {
                 self._focus = .file
             case 1:
                 let key = decoder.codingPath[0]
-                let r = try key.intValue ?! DecodingError._invalidKey(forRow: key, codingPath: decoder.codingPath)
+                let r = try key.intValue ?> CSVDecoder.Error._invalidRowKey(forKey: key, codingPath: decoder.codingPath)
                 self._focus = .row(r)
             default:
-                throw DecodingError._invalidContainerRequest(codingPath: decoder.codingPath)
+                throw CSVDecoder.Error._invalidContainerRequest(forKey: decoder.codingPath.last!, codingPath: decoder.codingPath)
             }
             self._decoder = decoder
         }
@@ -78,32 +78,32 @@ extension ShadowDecoder.KeyedContainer {
     func nestedContainer<NestedKey>(keyedBy type: NestedKey.Type, forKey key: Key) throws -> KeyedDecodingContainer<NestedKey> where NestedKey : CodingKey {
         switch self._focus {
         case .file:
-            guard let rowIndex = key.intValue else { throw DecodingError._invalidKey(forRow: key, codingPath: self.codingPath + [key]) }
+            guard let rowIndex = key.intValue else { throw CSVDecoder.Error._invalidRowKey(forKey: key, codingPath: self.codingPath + [key]) }
             var codingPath = self._decoder.codingPath; codingPath.append(IndexKey(rowIndex))
             let decoder = ShadowDecoder(source: self._decoder.source, codingPath: codingPath)
             return KeyedDecodingContainer(ShadowDecoder.KeyedContainer<NestedKey>(unsafeDecoder: decoder, rowIndex: rowIndex))
-        case .row: throw DecodingError._invalidContainerRequest(codingPath: self.codingPath)
+        case .row: throw CSVDecoder.Error._invalidContainerRequest(forKey: key, codingPath: self.codingPath)
         }
     }
 
     func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
         switch self._focus {
         case .file:
-            guard let rowIndex = key.intValue else { throw DecodingError._invalidKey(forRow: key, codingPath: self.codingPath + [key]) }
+            guard let rowIndex = key.intValue else { throw CSVDecoder.Error._invalidRowKey(forKey: key, codingPath: self.codingPath + [key]) }
             var codingPath = self._decoder.codingPath; codingPath.append(IndexKey(rowIndex))
             let decoder = ShadowDecoder(source: self._decoder.source, codingPath: codingPath)
             return ShadowDecoder.UnkeyedContainer(unsafeDecoder: decoder, rowIndex: rowIndex)
-        case .row: throw DecodingError._invalidContainerRequest(codingPath: self.codingPath)
+        case .row: throw CSVDecoder.Error._invalidContainerRequest(forKey: key, codingPath: self.codingPath)
         }
     }
 
     func superDecoder(forKey key: Key) throws -> Decoder {
         switch self._focus {
         case .file:
-            guard let rowIndex = key.intValue else { throw DecodingError._invalidKey(forRow: key, codingPath: self.codingPath + [key]) }
+            guard let rowIndex = key.intValue else { throw CSVDecoder.Error._invalidRowKey(forKey: key, codingPath: self.codingPath + [key]) }
             var codingPath = self._decoder.codingPath; codingPath.append(IndexKey(rowIndex))
             return ShadowDecoder(source: self._decoder.source, codingPath: codingPath)
-        case .row: throw DecodingError._invalidContainerRequest(codingPath: self.codingPath)
+        case .row: throw CSVDecoder.Error._invalidContainerRequest(forKey: key, codingPath: self.codingPath)
         }
     }
 
@@ -112,13 +112,11 @@ extension ShadowDecoder.KeyedContainer {
         case .file:
             var codingPath = self._decoder.codingPath; codingPath.append(IndexKey(0))
             return ShadowDecoder(source: self._decoder.source, codingPath: codingPath)
-        case .row: throw DecodingError._invalidContainerRequest(codingPath: self.codingPath)
+        case .row: throw CSVDecoder.Error._invalidContainerRequest(forKey: NameKey(index: 0, name: "super"), codingPath: self.codingPath)
         }
     }
 }
 
-// MARK: -
-
 extension ShadowDecoder.KeyedContainer {
     func decode(_ type: String.Type, forKey key: Key) throws -> String {
         try self._fieldContainer(forKey: key).decode(String.self)
@@ -281,9 +279,9 @@ private extension ShadowDecoder.KeyedContainer {
         case .row(let rowIndex):
             index = (rowIndex, try self._decoder.source.fieldIndex(forKey: key, codingPath: self.codingPath))
         case .file:
-            guard let rowIndex = key.intValue else { throw DecodingError._invalidKey(forRow: key, codingPath: codingPath) }
+            guard let rowIndex = key.intValue else { throw CSVDecoder.Error._invalidRowKey(forKey: key, codingPath: codingPath) }
             // Values are only allowed to be decoded directly from a nested container in "file level" if the CSV rows have a single column.
-            guard self._decoder.source.numExpectedFields == 1 else { throw DecodingError._invalidNestedRequired(codingPath: self.codingPath) }
+            guard self._decoder.source.numExpectedFields == 1 else { throw CSVDecoder.Error._invalidNestedRequired(codingPath: self.codingPath) }
             index = (rowIndex, 0)
             codingPath.append(IndexKey(index.field))
         }
@@ -293,26 +291,29 @@ private extension ShadowDecoder.KeyedContainer {
     }
 }
 
-fileprivate extension DecodingError {
+fileprivate extension CSVDecoder.Error {
     /// Error raised when a coding key representing a row within the CSV file cannot be transformed into an integer value.
-    /// - parameter codingPath: The whole coding path, including the invalid row key.
-    static func _invalidKey(forRow key: CodingKey, codingPath: [CodingKey]) -> DecodingError {
-        DecodingError.keyNotFound(key, .init(
-            codingPath: codingPath,
-            debugDescription: "The coding key identifying a CSV row couldn't be transformed into an integer value."))
+    /// - parameter codingPath: The full decoding chain.
+    static func _invalidRowKey(forKey key: CodingKey, codingPath: [CodingKey]) -> CSVError<CSVDecoder> {
+        .init(.invalidPath,
+              reason: "The coding key identifying a CSV row couldn't be transformed into an integer value.",
+              help: "The provided coding key identifying a CSV row must implement `intValue`.",
+              userInfo: ["Coding path": codingPath, "Key": key])
     }
     /// Error raised when a keyed container is requested on an invalid coding path.
-    /// - parameter codingPath: The full chain of containers which generated this error.
-    static func _invalidContainerRequest(codingPath: [CodingKey]) -> DecodingError {
-        DecodingError.dataCorrupted(
-            Context(codingPath: codingPath,
-                    debugDescription: "CSV doesn't support more than two nested decoding container.")
-        )
+    /// - parameter codingPath: The full decoding chain.
+    static func _invalidContainerRequest(forKey key: CodingKey, codingPath: [CodingKey]) -> CSVError<CSVDecoder> {
+        .init(.invalidPath,
+              reason: "A CSV doesn't support more than two nested decoding container.",
+              help: "Don't ask for a nested container on the targeted key for this coding path.",
+              userInfo: ["Coding path": codingPath, "Key": key])
     }
     /// Error raised when a value is decoded, but a container was expected by the decoder.
-    static func _invalidNestedRequired(codingPath: [CodingKey]) -> DecodingError {
-        DecodingError.dataCorrupted(.init(
-            codingPath: codingPath,
-            debugDescription: "A nested container is needed to decode CSV row values"))
+    /// - parameter codingPath: The full decoding chain.
+    static func _invalidNestedRequired(codingPath: [CodingKey]) -> CSVError<CSVDecoder> {
+        .init(.invalidPath,
+              reason: "A nested container is needed to decode CSV row values",
+              help: "Request a nested container instead of trying to decode a value directly.",
+              userInfo: ["Coding path": codingPath])
     }
 }