swift-tools-version: 5.8

yngrtc · yngrtc · commit d6ab76c068cc · 2024-06-02T11:53:30.000-07:00
diff --git a/.github/workflows/swift.yml b/.github/workflows/swift.yml
@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest]
-        swift: ["5.9"]
+        swift: ["5.8"]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
diff --git a/Package.swift b/Package.swift
@@ -1,4 +1,4 @@
-// swift-tools-version: 5.9
+// swift-tools-version: 5.8
 //===----------------------------------------------------------------------===//
 //
 // This source file is part of the SwiftRTC open source project
@@ -80,7 +80,7 @@ let package = Package(
         .testTarget(name: "SDPTests", dependencies: ["SDP"]),
         .testTarget(name: "SharedTests", dependencies: ["Shared"]),
         .testTarget(name: "SRTPTests", dependencies: ["SRTP"]),
-        .testTarget(name: "STUNTests", 
+        .testTarget(name: "STUNTests",
             dependencies: [
                 "STUN",
                 .product(name: "ExtrasBase64", package: "swift-extras-base64"),
diff --git a/Sources/SDP/SessionDescription.swift b/Sources/SDP/SessionDescription.swift
@@ -1017,15 +1017,12 @@ func unmarshalConnectionInformation(value: String) throws -> ConnectionInformati
     }
 
     let address: Address? =
-        if fields.count > 2 {
-            Address(
-                address: fields[2],
-                ttl: nil,
-                range: nil
-            )
-        } else {
-            nil
-        }
+        fields.count > 2
+        ? Address(
+            address: fields[2],
+            ttl: nil,
+            range: nil
+        ) : nil
 
     return ConnectionInformation(
         networkType: fields[0],
@@ -1155,16 +1152,10 @@ func unmarshalSessionAttribute(lexer: inout Lexer) throws -> StateFn? {
     let value = try lexer.readValue()
 
     let fields = value.split(separator: ":", maxSplits: 1).map { String($0) }
-    let attribute =
-        if fields.count == 2 {
-            Attribute(
-                key: fields[0],
-                value: fields[1]
-            )
-        } else {
-            Attribute(
-                key: fields[0])
-        }
+    let attribute = Attribute(
+        key: fields[0],
+        value: fields.count == 2 ? fields[1] : nil
+    )
     lexer.desc.attributes.append(attribute)
 
     return StateFn(f: s11)
@@ -1294,16 +1285,10 @@ func unmarshalMediaAttribute(lexer: inout Lexer) throws -> StateFn? {
     let value = try lexer.readValue()
 
     let fields = value.split(separator: ":", maxSplits: 1).map { String($0) }
-    let attribute =
-        if fields.count == 2 {
-            Attribute(
-                key: fields[0],
-                value: fields[1])
-        } else {
-            Attribute(
-                key: fields[0])
-        }
-
+    let attribute = Attribute(
+        key: fields[0],
+        value: fields.count == 2 ? fields[1] : nil
+    )
     if lexer.desc.mediaDescriptions.isEmpty {
         throw SDPError.sdpEmptyTimeDescription
     }
@@ -1317,23 +1302,26 @@ func unmarshalMediaAttribute(lexer: inout Lexer) throws -> StateFn? {
 func parseTimeUnits(value: String) throws -> Int64 {
     // Some time offsets in the protocol can be provided with a shorthand
     // notation. This code ensures to convert it to NTP timestamp format.
-    let (num, factor) =
-        if let last = value.last {
-            switch last {
-            case "d":
-                (String(value.dropLast()), 86400)  // days
-            case "h":
-                (String(value.dropLast()), 3600)  // hours
-            case "m":
-                (String(value.dropLast()), 60)  // minutes
-            case "s":
-                (String(value.dropLast()), 1)  // seconds (allowed for completeness)
-            default:
-                (value, 1)
-            }
-        } else {
-            (value, 1)
+    var (num, factor) = (value, 1)
+    if let last = value.last {
+        switch last {
+        case "d":
+            num = String(value.dropLast())
+            factor = 86400  // days
+        case "h":
+            num = String(value.dropLast())
+            factor = 3600  // hours
+        case "m":
+            num = String(value.dropLast())
+            factor = 60  // minutes
+        case "s":
+            num = String(value.dropLast())
+            factor = 1  // seconds (allowed for completeness)
+        default:
+            num = value
+            factor = 1
         }
+    }
 
     guard let parsedNum = Int64(num) else {
         throw SDPError.sdpInvalidValue(value)
diff --git a/Sources/STUN/Address.swift b/Sources/STUN/Address.swift
@@ -49,27 +49,22 @@ public struct MappedAddress {
         }
         let port = UInt16.fromBeBytes(v[2], v[3])
 
-        let l =
-            if family == familyIpV6 {
-                min(ipV6Len, v[4...].count)
-            } else {
-                min(ipV4Len, v[4...].count)
-            }
+        let l = family == familyIpV6 ? min(ipV6Len, v[4...].count) : min(ipV4Len, v[4...].count)
         self.socketAddress = try SocketAddress(
             packedIPAddress: ByteBuffer(bytes: v[4..<4 + l]), port: Int(port))
     }
 
     /// adds MAPPED-ADDRESS value to m as t attribute.
     public func addToAs(_ m: inout Message, _ t: AttrType) throws {
-        let family =
-            switch self.socketAddress {
-            case SocketAddress.v4(_):
-                familyIpV4
-            case SocketAddress.v6(_):
-                familyIpV6
-            default:
-                throw STUNError.errInvalidFamilyIpValue(0)
-            }
+        var family = familyIpV4
+        switch self.socketAddress {
+        case SocketAddress.v4(_):
+            family = familyIpV4
+        case SocketAddress.v6(_):
+            family = familyIpV6
+        default:
+            throw STUNError.errInvalidFamilyIpValue(0)
+        }
 
         guard let port = self.socketAddress.port else {
             throw STUNError.errInvalidFamilyIpValue(0)
diff --git a/Sources/STUN/ErrorCodeAttribute.swift b/Sources/STUN/ErrorCodeAttribute.swift
@@ -74,14 +74,13 @@ extension ErrorCodeAttribute: Getter {
         let numberByte = UInt16(v[errorCodeNumberByte])
         let code = classByte * errorCodeModulo + numberByte
         self.code = ErrorCode(code)
-        self.reason =
-            if let reason = b.getString(
-                at: errorCodeReasonStart, length: v.count - errorCodeReasonStart)
-            {
-                reason
-            } else {
-                throw STUNError.errInvalidString
-            }
+        if let reason = b.getString(
+            at: errorCodeReasonStart, length: v.count - errorCodeReasonStart)
+        {
+            self.reason = reason
+        } else {
+            throw STUNError.errInvalidString
+        }
     }
 }
 
diff --git a/Sources/STUN/TextAttribute.swift b/Sources/STUN/TextAttribute.swift
@@ -73,19 +73,19 @@ extension TextAttribute: Setter {
     /// adds attribute with type t to m, checking maximum length. If max_len
     /// is less than 0, no check is performed.
     public func addTo(_ m: inout Message) throws {
-        let maxLen =
-            switch self.attr {
-            case attrUsername:
-                maxUsernameB
-            case attrRealm:
-                maxRealmB
-            case attrSoftware:
-                maxSoftwareB
-            case attrNonce:
-                maxNonceB
-            default:
-                throw STUNError.errUnsupportedAttrType(self.attr)
-            }
+        var maxLen = maxUsernameB
+        switch self.attr {
+        case attrUsername:
+            maxLen = maxUsernameB
+        case attrRealm:
+            maxLen = maxRealmB
+        case attrSoftware:
+            maxLen = maxSoftwareB
+        case attrNonce:
+            maxLen = maxNonceB
+        default:
+            throw STUNError.errUnsupportedAttrType(self.attr)
+        }
         let text = ByteBuffer(string: self.text)
         let textView = ByteBufferView(text)
         try checkOverflow(self.attr, textView.count, maxLen)
diff --git a/Sources/STUN/Uri.swift b/Sources/STUN/Uri.swift
@@ -59,26 +59,18 @@ public struct Uri: Equatable {
             .trimmingPrefix("[")
             .trimmingSuffix("]")
 
-        let port: UInt16? =
-            if let port = url.port {
-                UInt16(port)
-            } else {
-                nil
-            }
+        var port: UInt16? = nil
+        if let p = url.port {
+            port = UInt16(p)
+        }
 
         return Uri(scheme: url.scheme, host: String(host), port: port)
     }
 }
 
 extension Uri: CustomStringConvertible {
     public var description: String {
-        let host =
-            if self.host.contains(":") {
-                "[\(self.host)]"
-            } else {
-                self.host
-            }
-
+        let host = self.host.contains(":") ? "[\(self.host)]" : self.host
         if let port = self.port {
             return "\(self.scheme):\(host):\(port)"
         } else {
diff --git a/Sources/STUN/XorMappedAddress.swift b/Sources/STUN/XorMappedAddress.swift
@@ -53,15 +53,17 @@ public struct XorMappedAddress {
 
     /// add_to_as adds XOR-MAPPED-ADDRESS value to m as t attribute.
     public func addToAs(_ m: inout Message, _ t: AttrType) throws {
-        let (family, ipLen) =
-            switch self.socketAddress {
-            case SocketAddress.v4(_):
-                (familyIpV4, ipV4Len)
-            case SocketAddress.v6(_):
-                (familyIpV6, ipV6Len)
-            default:
-                throw STUNError.errInvalidFamilyIpValue(0)
-            }
+        var (family, ipLen) = (familyIpV4, ipV4Len)
+        switch self.socketAddress {
+        case SocketAddress.v4(_):
+            family = familyIpV4
+            ipLen = ipV4Len
+        case SocketAddress.v6(_):
+            family = familyIpV6
+            ipLen = ipV6Len
+        default:
+            throw STUNError.errInvalidFamilyIpValue(0)
+        }
 
         guard let port = self.socketAddress.port else {
             throw STUNError.errInvalidFamilyIpValue(0)
@@ -97,12 +99,7 @@ public struct XorMappedAddress {
             throw STUNError.errInvalidFamilyIpValue(family)
         }
 
-        let ipLen =
-            if family == familyIpV4 {
-                ipV4Len
-            } else {
-                ipV6Len
-            }
+        let ipLen = family == familyIpV4 ? ipV4Len : ipV6Len
         try checkOverflow(t, v[4...].count, ipLen)
 
         let port = UInt16.fromBeBytes(v[2], v[3]) ^ UInt16(magicCookie >> 16)
diff --git a/Sources/XExampleStunDecode/main.swift b/Sources/XExampleStunDecode/main.swift
@@ -21,10 +21,7 @@ import STUN
 // just to get an ArraySlice<String> from [String]
 let arguments = CommandLine.arguments.dropFirst()
 
-guard let encodedData = arguments.first else {
-    print("data is missing")
-    exit(1)
-}
+let encodedData = arguments.first!
 
 let decodedData = try Base64.decode(string: encodedData)
 
