Always parse the ABI component of target triples (#330)

Previously, we were ignoring the ABI component unless it started with the literal string "android". This seems incorrect, we should be including any type of ABI component if it is present in a triple.

Author: neonichu

Sources/TSCUtility/Triple.swift

@@ -67,9 +67,41 @@ public struct Triple: Encodable, Equatable {
         case openbsd
     }
 
-    public enum ABI: String, Encodable {
+    public enum ABI: Encodable, Equatable, RawRepresentable {
         case unknown
         case android
+        case other(name: String)
+
+        public init?(rawValue: String) {
+            if rawValue.hasPrefix(ABI.android.rawValue) {
+                self = .android
+            } else if let version = rawValue.firstIndex(where: { $0.isNumber }) {
+                self = .other(name: String(rawValue[..<version]))
+            } else {
+                self = .other(name: rawValue)
+            }
+        }
+
+        public var rawValue: String {
+            switch self {
+            case .android: return "android"
+            case .other(let name): return name
+            case .unknown: return "unknown"
+            }
+        }
+
+        public static func ==(lhs: ABI, rhs: ABI) -> Bool {
+            switch (lhs, rhs) {
+            case (.unknown, .unknown):
+                return true
+            case (.android, .android):
+                return true
+            case let (.other(lhsName), .other(rhsName)):
+                return lhsName == rhsName
+            default:
+                return false
+            }
+        }
     }
 
     public init(_ string: String) throws {
@@ -91,7 +123,7 @@ public struct Triple: Encodable, Equatable {
 
         let osVersion = Triple.parseVersion(components[2])
 
-        let abi = components.count > 3 ? Triple.parseABI(components[3]) : nil
+        let abi = components.count > 3 ? Triple.ABI(rawValue: components[3]) : nil
         let abiVersion = components.count > 3 ? Triple.parseVersion(components[3]) : nil
 
         self.tripleString = string
@@ -119,13 +151,6 @@ public struct Triple: Encodable, Equatable {
         return nil
     }
 
-    fileprivate static func parseABI(_ string: String) -> ABI? {
-        if string.hasPrefix(ABI.android.rawValue) {
-            return ABI.android
-        }
-        return nil
-    }
-
     public func isAndroid() -> Bool {
         return os == .linux && abi == .android
     }

Tests/TSCUtilityTests/TripleTests.swift

@@ -17,6 +17,8 @@ class TripleTests : XCTestCase {
         XCTAssertNotNil(linux)
         XCTAssertEqual(linux!.os, .linux)
         XCTAssertNil(linux!.osVersion)
+        XCTAssertEqual(linux!.abi, .other(name: "gnu"))
+        XCTAssertNil(linux!.abiVersion)
 
         let macos = try? Triple("x86_64-apple-macosx10.15")
         XCTAssertNotNil(macos!)
@@ -32,7 +34,12 @@ class TripleTests : XCTestCase {
         let android = try? Triple("aarch64-unknown-linux-android24")
         XCTAssertNotNil(android)
         XCTAssertEqual(android!.os, .linux)
+        XCTAssertEqual(android!.abi, .android)
         XCTAssertEqual(android!.abiVersion, "24")
+
+        let linuxWithABIVersion = try? Triple("x86_64-unknown-linux-gnu42")
+        XCTAssertEqual(linuxWithABIVersion!.abi, .other(name: "gnu"))
+        XCTAssertEqual(linuxWithABIVersion!.abiVersion, "42")
     }
 
     func testEquality() throws {
@@ -42,6 +49,10 @@ class TripleTests : XCTestCase {
 
         let intelMacOSTriple = try Triple("x86_64-apple-macos")
         XCTAssertNotEqual(macOSTriple, intelMacOSTriple)
+
+        let linuxWithoutGNUABI = try Triple("x86_64-unknown-linux")
+        let linuxWithGNUABI = try Triple("x86_64-unknown-linux-gnu")
+        XCTAssertNotEqual(linuxWithoutGNUABI, linuxWithGNUABI)
     }
 
     func testWASI() throws {