Handle both LF and CRLF #37

Author: dehesa

sources/Delimiter.swift

@@ -2,60 +2,132 @@
 public enum Delimiter {
     /// The CSV pair of delimiters (field & row delimiters).
     public typealias Pair = (field: Self.Field, row: Self.Row)
-    /// The CSV pair of delimiter in string format.
-    internal typealias RawPair = (field: [Unicode.Scalar], row: [Unicode.Scalar])
 }
 
 extension Delimiter {
     /// The delimiter between fields/values.
-    public struct Field: ExpressibleByNilLiteral, ExpressibleByStringLiteral, RawRepresentable {
-        public let rawValue: String.UnicodeScalarView
+    ///
+    /// If the delimiter is initialized with `nil`, it implies the field delimiter is unknown and the system should try to figure it out.
+    public struct Field: ExpressibleByNilLiteral, ExpressibleByStringLiteral, CustomStringConvertible {
+        /// The accepted field delimiter. Usually a comma `,`.
+        ///
+        /// If it's empty, the field delimiter is unknown.
+        internal let scalars: [Unicode.Scalar]
 
         public init(nilLiteral: ()) {
-            self.rawValue = .init()
+            self.scalars = Array()
         }
 
         public init(unicodeScalarLiteral value: Unicode.Scalar) {
-            self.rawValue = .init(repeating: value, count: 1)
+            self.scalars = [value]
         }
 
         public init(stringLiteral value: String) {
-            self.rawValue = value.unicodeScalars
+            precondition(!value.isEmpty)
+            self.scalars = Array(value.unicodeScalars)
         }
 
-        public init?(rawValue: String.UnicodeScalarView) {
-            self.rawValue = rawValue
+        /// The field delimiter is represented by the given `String`-like type.
+        /// - parameter delimiter: The exact composition of the field delimiter. If empty, the initializer fails returning `nil`.
+        public init?<S:StringProtocol>(_ delimiter: S) {
+            guard !delimiter.isEmpty else { return nil }
+            self.scalars = Array(delimiter.unicodeScalars)
         }
 
-        public init<S:StringProtocol>(_ value: S) {
-            self.rawValue = String.UnicodeScalarView(value.unicodeScalars)
+        /// Boolean indicating if the exact unicode scalar composition for the field delimiter is known or unknown.
+        internal var isKnown: Bool {
+            !self.scalars.isEmpty
+        }
+        
+        /// Returns the `String` representation of the field delimiter.
+        public var description: String {
+            String(String.UnicodeScalarView(self.scalars))
         }
     }
 }
 
 extension Delimiter {
     /// The delimiter between rows.
-    public struct Row: ExpressibleByNilLiteral, ExpressibleByStringLiteral, RawRepresentable {
-        public let rawValue: String.UnicodeScalarView
+    ///
+    /// If the delimiter is initialized with `nil`, it implies the row delimiter is unknown and the system should try to figure it out.
+    public struct Row: ExpressibleByStringLiteral, ExpressibleByNilLiteral, CustomStringConvertible {
+        /// All the accepted row delimiters. Usually, it is only one.
+        /// - invariant: The elements of the set (i.e. the arrays) always contain at least one element.
+        internal let scalars: Set<[Unicode.Scalar]>
+        
+        /// Specifies two row delimiters: CR (Carriage Return) LF (Line Feed) `\r\n` and s single line feed `\n`.
+        ///
+        /// This delimiter is intended to be used with CSVs where the end of the row may be marked with a CRLF sometimes and other times with LF.
+        public static var standard: Self {
+            self.init("\n", "\r\n")!
+        }
 
         public init(nilLiteral: ()) {
-            self.rawValue = .init()
+            self.scalars = Set()
         }
 
         public init(unicodeScalarLiteral value: Unicode.Scalar) {
-            self.rawValue = .init(repeating: value, count: 1)
+            var delimiters = Set<[Unicode.Scalar]>(minimumCapacity: 1)
+            delimiters.insert([value])
+            self.scalars = delimiters
         }
 
         public init(stringLiteral value: String) {
-            self.rawValue = value.unicodeScalars
+            precondition(!value.isEmpty)
+            
+            var delimiters = Set<[Unicode.Scalar]>(minimumCapacity: 1)
+            delimiters.insert(Array(value.unicodeScalars))
+            self.scalars = delimiters
+        }
+        
+        /// Creates one or more possible row delimiters.
+        /// - parameter delimiters:The exact composition of the row delimiters. If any of the `delimiters` is empty, the initializer fails returning `nil`.
+        public init?<S:StringProtocol>(_ delimiters: S...) {
+            let scalars: [[Unicode.Scalar]] = delimiters.compactMap {
+                guard !$0.isEmpty else { return nil }
+                return Array($0.unicodeScalars)
+            }
+            guard !scalars.isEmpty else { return nil }
+            self.scalars = Set(scalars)
         }
 
-        public init?(rawValue: String.UnicodeScalarView) {
-            self.rawValue = rawValue
+        /// Boolean indicating if the exact unicode scalar composition for the row delimiter is known or unknown.
+        internal var isKnown: Bool {
+            !self.scalars.isEmpty
         }
 
-        public init<S:StringProtocol>(_ value: S) {
-            self.rawValue = String.UnicodeScalarView(value.unicodeScalars)
+        /// Returns the `String` representation of the row delimiter.
+        ///
+        /// If more than one row has been provided, the `String` with less number of characters and less value (i.e. less Integer value) is selected.
+        public var description: String {
+            String(String.UnicodeScalarView(self.scalars.min {
+                guard $0.count == $1.count else { return $0.count < $1.count }
+                for (lhs, rhs) in zip($0, $1) where lhs != rhs { return lhs < rhs }
+                return true
+            }!))
+        }
+    }
+}
+
+internal extension Delimiter {
+    /// Contains the exact composition of a CSV field and row delimiter.
+    struct Scalars {
+        /// The exact composition of unicode scalars indetifying a field delimiter.
+        /// - invariant: The array always contains at least one element.
+        let field: [Unicode.Scalar]
+        /// All possile row delimiters specifying its exact compositon of unicode scalars.
+        /// - invariant: The set always contains at least one element and all set elements always contain at least on scalar.
+        let row: Set<[Unicode.Scalar]>
+        
+        /// Designated initializer checking that the delimiters aren't empty and the field delimiter is not included in the row delimiter.
+        /// - parameter field: The exact composition of the field delimiter. If empty, `nil` is returned.
+        /// - parameter row: The exact composition of all possible row delimiters. If it is empty or any of its elements is an empty array, `nil` is returned.
+        init?(field: [Unicode.Scalar], row: Set<[Unicode.Scalar]>) {
+            guard !field.isEmpty else { return nil }
+            self.field = field
+            guard !row.isEmpty, row.allSatisfy({ !$0.isEmpty }) else { return nil }
+            self.row = row
+            guard self.row.allSatisfy({ $0 != self.field }) else { return nil }
         }
     }
 }

sources/Deprecated.swift

@@ -19,9 +19,9 @@ public final class CSVReader: IteratorProtocol, Sequence {
     /// The unicode scalar decoder providing all input data.
     private let _decoder: ScalarDecoder
     /// Check whether the given unicode scalar is part of the field delimiter sequence.
-    private let _isFieldDelimiter: DelimiterChecker
+    private let _isFieldDelimiter: Delimiter.Scalars.Checker
     /// Check whether the given unicode scalar is par of the row delimiter sequence.
-    private let _isRowDelimiter: DelimiterChecker
+    private let _isRowDelimiter: Delimiter.Scalars.Checker
     /// The amount of rows (counting the header row) that have been read and the amount of fields that should be in each row.
     internal private(set) var count: (rows: Int, fields: Int)
     /// The reader status indicating whether there are remaning lines to read, the CSV has been completely parsed, or an error occurred and no further operation shall be performed.
@@ -40,8 +40,8 @@ public final class CSVReader: IteratorProtocol, Sequence {
         self._fieldBuffer = .init()
         self._fieldBuffer.reserveCapacity(128)
         self._decoder = decoder
-        self._isFieldDelimiter = CSVReader.makeMatcher(delimiter: self._settings.delimiters.field, buffer: self._scalarBuffer, decoder: self._decoder)
-        self._isRowDelimiter = CSVReader.makeMatcher(delimiter: self._settings.delimiters.row, buffer: self._scalarBuffer, decoder: self._decoder)
+        self._isFieldDelimiter = self._settings.delimiters.makeFieldMatcher(buffer: self._scalarBuffer, decoder: self._decoder)
+        self._isRowDelimiter = self._settings.delimiters.makeRowMatcher(buffer: self._scalarBuffer, decoder: self._decoder)
         self.count = (0, 0)
         self.status = .active
 
@@ -328,7 +328,7 @@ fileprivate extension CSVReader.Error {
     static func _invalidUnescapedField(rowIndex: Int) -> CSVError<CSVReader> {
         .init(.invalidInput,
               reason: "The escaping scalar (double quotes by default) is not allowed within fields which aren't already escaped.",
-              help: "Add the escaping scalar add the very beginning and the very end of the field and escape the escaping scalar found within the field.",
+              help: "Add the escaping scalar at the very beginning and the very end of the field and escape the escaping scalar found within the field.",
               userInfo: ["Row index": rowIndex])
     }
     /// Error raised when an EOF has been received but the last CSV field was not finalized.