Remove unneeded code

Author: t089

Sources/AWSLambdaEvents/Utils/DateWrappers.swift

@@ -79,12 +79,8 @@ public struct RFC5322DateTimeCoding: Decodable, Sendable {
 
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
-        var string = try container.decode(String.self)
-        // RFC5322 dates sometimes have the alphabetic version of the timezone in brackets after the numeric version. The date formatter
-        // fails to parse this so we need to remove this before parsing.
-        if let bracket = string.firstIndex(of: "(") {
-            string = String(string[string.startIndex..<bracket]._timming(while: { $0.isWhitespace }))
-        }
+        let string = try container.decode(String.self)
+
         do {
             self.wrappedValue = try Date(string, strategy: RFC5322DateStrategy())
         } catch {
@@ -95,44 +91,6 @@ public struct RFC5322DateTimeCoding: Decodable, Sendable {
             )
         }
     }
-
-    /*private static var dateFormatters: [DateFormatter] {
-        // rfc5322 dates received in SES mails sometimes do not include the day, so need two dateformatters
-        // one with a day and one without
-        let formatterWithDay = DateFormatter()
-        formatterWithDay.dateFormat = "EEE, d MMM yyy HH:mm:ss z"
-        formatterWithDay.locale = Locale(identifier: "en_US_POSIX")
-        let formatterWithoutDay = DateFormatter()
-        formatterWithoutDay.dateFormat = "d MMM yyy HH:mm:ss z"
-        formatterWithoutDay.locale = Locale(identifier: "en_US_POSIX")
-        return [formatterWithDay, formatterWithoutDay]
-    }*/
-}
-
-extension RangeReplaceableCollection {
-    func _timming(while predicate: (Element) -> Bool) -> SubSequence {
-        var idx = startIndex
-        while idx < endIndex && predicate(self[idx]) {
-            formIndex(after: &idx)
-        }
-
-        let startOfNonTrimmedRange = idx // Points at the first char not in the set
-        guard startOfNonTrimmedRange != endIndex else {
-            return self[endIndex...]
-        }
-
-        let beforeEnd = index(endIndex, offsetBy: -1)
-        guard startOfNonTrimmedRange < beforeEnd else {
-            return self[startOfNonTrimmedRange ..< endIndex]
-        }
-
-        var backIdx = beforeEnd
-        // No need to bound-check because we've already trimmed from the beginning, so we'd definitely break off of this loop before `backIdx` rewinds before `startIndex`
-        while predicate(self[backIdx]) {
-            formIndex(&backIdx, offsetBy: -1)
-        }
-        return self[startOfNonTrimmedRange ... backIdx]
-    }
 }
 
 struct RFC5322DateError: Error {}
@@ -149,23 +107,24 @@ struct RFC5322DateStrategy: ParseStrategy {
     }
 
     func components(from input: String) -> DateComponents? {
-        var s = input[...]
-        return s.withUTF8 { buffer -> DateComponents? in
-            // if the 4th character is a comma, then we have a day of the week
-            guard buffer.count > 5 else { return nil }
-            var offset = 0
-            if buffer[3] == UInt8(ascii: ",") {
-                offset = 5
-            }
+        var endIndex = input.endIndex
+        // If the date string has a timezone in brackets, we need to remove it before parsing.
+        if let bracket = input.firstIndex(of: "(") {
+            endIndex = bracket
+        }   
+        var s = input[input.startIndex..<endIndex]
+
+        let asciiNumbers = UInt8(ascii: "0") ... UInt8(ascii: "9")
 
+        return s.withUTF8 { buffer -> DateComponents? in
             func parseDay(_ it: inout UnsafeBufferPointer<UInt8>.Iterator) -> Int? {
                 let first = it.next()
                 let second = it.next()
                 guard let first = first, let second = second else { return nil }
 
-                guard first >= UInt8(ascii: "0") && first <= UInt8(ascii: "9") else { return nil }
+                guard asciiNumbers.contains(first) else { return nil }
 
-                if second >= UInt8(ascii: "0") && second <= UInt8(ascii: "9") {
+                if asciiNumbers.contains(second) {
                     return Int(first - UInt8(ascii: "0")) * 10 + Int(second - UInt8(ascii: "0"))
                 } else {
                     return Int(first - UInt8(ascii: "0"))
@@ -241,10 +200,15 @@ struct RFC5322DateStrategy: ParseStrategy {
 
             var it = buffer.makeIterator()
 
-            for _ in 0..<offset {
-                _ = it.next()
-            }
+            // if the 4th character is a comma, then we have a day of the week
+            guard buffer.count > 5 else { return nil }
 
+            if buffer[3] == UInt8(ascii: ",") {
+                for _ in 0..<5 {
+                    _ = it.next()
+                }
+            }
+
             guard let day = parseDay(&it) else { return nil }
             guard let month = parseMonth(&it) else { return nil }
             guard let year = parseYear(&it) else { return nil }
@@ -293,10 +257,9 @@ extension IteratorProtocol where Self.Element == UInt8 {
                     continue
                 }
             }
-            if c >= UInt8(ascii: "0") && c <= UInt8(ascii: "9") {
-                return c
-            } else {
-                return nil
+            switch c {
+                case UInt8(ascii: "0") ... UInt8(ascii: "9"): return c
+                default: return nil
             }
         }
         return nil
@@ -309,10 +272,11 @@ extension IteratorProtocol where Self.Element == UInt8 {
                     continue
                 }
             }
-            if c >= UInt8(ascii: "A") && c <= UInt8(ascii: "Z") || c >= UInt8(ascii: "a") && c <= UInt8(ascii: "z") {
-                return c
-            } else {
-                return nil
+
+            switch c {
+                case UInt8(ascii: "A") ... UInt8(ascii: "Z"),
+                     UInt8(ascii: "a") ... UInt8(ascii: "z"): return c
+                default: return nil
             }
         }
         return nil
@@ -321,7 +285,11 @@ extension IteratorProtocol where Self.Element == UInt8 {
 
 extension UInt8 {
     var isAsciiLetter: Bool {
-        return self >= UInt8(ascii: "A") && self <= UInt8(ascii: "Z") || self >= UInt8(ascii: "a") && self <= UInt8(ascii: "z")
+        switch self {
+            case UInt8(ascii: "A") ... UInt8(ascii: "Z"),
+                 UInt8(ascii: "a") ... UInt8(ascii: "z"): return true
+            default: return false
+        }
     }
 }
 
@@ -331,5 +299,11 @@ let monthMap : [Array<UInt8> : Int ] = [
 ]
 
 let timezoneOffsetMap: [Array<UInt8> : Int] = [
-    Array("UTC".utf8): 0, Array("GMT".utf8): 0, Array("EDT".utf8): -4 * 60, Array("CDT".utf8): -5 * 60, Array("MDT".utf8): -6 * 60, Array("PDT".utf8): -7 * 60
+    Array("UTC".utf8): 0,
+    Array("GMT".utf8): 0,
+    Array("EDT".utf8): -4 * 60,
+    Array("CDT".utf8): -5 * 60,
+    Array("MDT".utf8): -6 * 60,
+    Array("PDT".utf8): -7 * 60,
+    
 ]