correct semantic version parsing

The semantic versioning specification 2.0.0 [states](https://semver.org/#spec-item-9) that pre-release identifiers must be positioned after the version core, and build metadata identifiers after pre-release identifiers.

In the old implementation, if a version core was appended with metadata identifiers that contain hyphens ("-"), the first hyphen would be mistaken as an indication of pre-release identifiers thereafter. Then, the position of the first hyphen would be treated as where the version core ends, resulting in a false negative after it was found that the "version core" contained non-numeric characters.

For example: the semantic version `1.2.3+some-meta.data` is a well-formed, with `1.2.3` being the version core and `some-meta.data` the metadata identifiers. However, the old implementation of `Version.init?(_ versionString: String)` would falsely treat `1.2.3+some` as the version core and `meta.data` the pre-release identifiers.

The new implementation fixes this problem by restricting the search area for "+" to the substring after the first "-".

In addition, the logic for breaking up the version core into numeric identifiers has been rewritten to be more understandable.

---

Currently, the test fails because of a problem with overloaded initialisers (`Version.init(_ version: Version)` and `Version.init?(_ versionString: String`). After this problem is resolved, a new commit containing a complete set of test cases is likely to be squashed into this one.

Author: WowbaggersLiquidLunch

Sources/PackageDescription/Version+StringLiteralConvertible.swift

@@ -59,36 +59,42 @@ extension Version {
     }
 
     /// Initializes a version struct with the provided version string.
-    ///
-    /// - Parameters:
-    ///     - version: A version string to use for creating a new version struct.
+    /// - Parameter version: A version string to use for creating a new version struct.
     public init?(_ versionString: String) {
-        let prereleaseStartIndex = versionString.firstIndex(of: "-")
-        let metadataStartIndex = versionString.firstIndex(of: "+")
-
-        let requiredEndIndex = prereleaseStartIndex ?? metadataStartIndex ?? versionString.endIndex
-        let requiredCharacters = versionString.prefix(upTo: requiredEndIndex)
-        let requiredComponents = requiredCharacters
-            .split(separator: ".", maxSplits: 2, omittingEmptySubsequences: false)
-            .map(String.init)
-            .compactMap({ Int($0) })
-            .filter({ $0 >= 0 })
-
-        guard requiredComponents.count == 3 else { return nil }
-
-        self.major = requiredComponents[0]
-        self.minor = requiredComponents[1]
-        self.patch = requiredComponents[2]
-
-        func identifiers(start: String.Index?, end: String.Index) -> [String] {
-            guard let start = start else { return [] }
-            let identifiers = versionString[versionString.index(after: start)..<end]
-            return identifiers.split(separator: ".").map(String.init)
-        }
-
-        self.prereleaseIdentifiers = identifiers(
-            start: prereleaseStartIndex,
-            end: metadataStartIndex ?? versionString.endIndex)
-        self.buildMetadataIdentifiers = identifiers(start: metadataStartIndex, end: versionString.endIndex)
+        // SemVer 2.0.0 allows only ASCII alphanumerical characters and "-" in the version string, except for "." and "+" as delimiters. ("-" is used as a delimiter between the version core and pre-release identifiers, but it's allowed within pre-release and metadata identifiers as well.)
+        // Alphanumerics check will come later, after each identifier is split out (i.e. after the delimiters are removed).
+        guard versionString.allSatisfy( \.isASCII ) else { return nil }
+        
+        let prereleaseDelimiterIndex = versionString.firstIndex(of: "-")
+        // SemVer 2.0.0 requires that metadata identifiers come after pre-release identifiers
+        let metadataDelimiterIndex = versionString[(versionString.firstIndex(of: "-") ?? versionString.startIndex)...].firstIndex(of: "+")
+        
+        let prereleaseStartIndex = prereleaseDelimiterIndex.map(versionString.index(after:)) ?? versionString.endIndex
+        let metadataStartIndex = metadataDelimiterIndex.map(versionString.index(after:)) ?? versionString.endIndex
+        
+        let versionCore = versionString[..<(prereleaseDelimiterIndex ?? versionString.endIndex)]
+        let versionCoreIdentifiers = versionCore.split(separator: ".", omittingEmptySubsequences: false)
+        
+        guard
+            versionCoreIdentifiers.count == 3,
+            // Major, minor, and patch versions must be ASCII numbers, according to the semantic versioning standard.
+            // Converting each identifier from a substring to an integer fails if the identifiers have illegal characters (except for "-").
+            // Comparisons against 0 fail if the identifiers have "-".
+            let major = Int(versionCoreIdentifiers[0]), major >= 0,
+            let minor = Int(versionCoreIdentifiers[1]), minor >= 0,
+            let patch = Int(versionCoreIdentifiers[2]), patch >= 0
+        else { return nil }
+        
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+        
+        let prereleaseIdentifiers = versionString[prereleaseStartIndex..<(metadataDelimiterIndex ?? versionString.endIndex)].split(separator: ".")
+        guard prereleaseIdentifiers.allSatisfy( { $0.allSatisfy { $0.isLetter || $0.isNumber || $0 == "-" } } ) else { return nil }
+        self.prereleaseIdentifiers = prereleaseIdentifiers.map { String($0) }
+        
+        let buildMetadataIdentifiers = versionString[metadataStartIndex...].split(separator: ".")
+        guard buildMetadataIdentifiers.allSatisfy( { $0.allSatisfy { $0.isLetter || $0.isNumber || $0 == "-" } } ) else { return nil }
+        self.buildMetadataIdentifiers = buildMetadataIdentifiers.map { String($0) }
     }
 }

Tests/PackageDescriptionTests/VersionTests.swift

@@ -22,6 +22,13 @@ class VersionTests: XCTestCase {
         XCTAssertLessThan(Version("1.2.3-alpha.beta.2"), Version("1.2.3-alpha.beta.3"))
 
         XCTAssertEqual(Version("1.2.3-alpha.beta.2").description, "1.2.3-alpha.beta.2")
+        
+        
+        
+        XCTAssertNotNil(Version("0.0.0"))
+        XCTAssertNotNil(Version("1.2.3"))
+        XCTAssertNil(Version("4.2"))
+
     }
 }