update

Author: swiftuiux

Sources/swiftui-loop-videoplayer/ext+/URL+.swift

@@ -10,23 +10,32 @@ import Foundation
 
 extension URL {
 
-    /// Validates a string as a well-formed HTTP or HTTPS URL and returns a URL object if valid.
-    ///
-    /// - Parameter urlString: The string to validate as a URL.
-    /// - Returns: An optional URL object if the string is a valid URL.
-    /// - Throws: An error if the URL is not valid or cannot be created.
-    static func validURLFromString(_ string: String) -> URL? {
-        let pattern = "^(https?:\\/\\/)(([a-zA-Z0-9-]+\\.)*[a-zA-Z0-9-]+\\.[a-zA-Z]{2,})(:\\d{1,5})?(\\/[\\S]*)?$"
-        let regex = try? NSRegularExpression(pattern: pattern, options: [])
-
-        let matches = regex?.matches(in: string, options: [], range: NSRange(location: 0, length: string.utf16.count))
-
-        guard let _ = matches, !matches!.isEmpty else {
-            // If no matches are found, the URL is not valid
-            return nil
+    /// Validates and returns an HTTP/HTTPS URL or nil.
+    /// Strategy:
+    /// 1) Parse once to detect an existing scheme (mailto, ftp, etc.).
+    /// 2) If a scheme exists and it's not http/https -> reject.
+    /// 3) If no scheme exists -> optionally prepend https:// and parse again.
+    static func validURLFromString(from raw: String, assumeHTTPSIfMissing: Bool = true) -> URL? {
+        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        
+        // First parse to detect an existing scheme.
+        if let pre = URLComponents(string: trimmed), let scheme = pre.scheme?.lowercased() {
+            // Reject anything that is not http/https.
+            guard scheme == "http" || scheme == "https" else { return nil }
+            
+            let comps = pre
+            // Require a host
+            guard let host = comps.host, !host.isEmpty else { return nil }
+            // Validate port range
+            if let port = comps.port, !(1...65535).contains(port) { return nil }
+            return comps.url
         }
 
-        // If a match is found, attempt to create a URL object
-        return URL(string: string)
+        // No scheme present -> optionally add https://
+        guard assumeHTTPSIfMissing else { return nil }
+        guard let comps = URLComponents(string: "https://" + trimmed) else { return nil }
+        guard let host = comps.host, !host.isEmpty else { return nil }
+        if let port = comps.port, !(1...65535).contains(port) { return nil }
+        return comps.url
     }
 }

Sources/swiftui-loop-videoplayer/fn/fn+.swift

@@ -44,7 +44,7 @@ func subtitlesAssetFor(_ settings: VideoSettings) -> AVURLAsset? {
 /// - Returns: An optional `AVURLAsset`, or `nil` if neither a valid URL nor a local resource file is found.
 fileprivate func assetFrom(name: String, fileExtension: String?) -> AVURLAsset? {
     // Attempt to create a valid URL from the provided string.
-    if let url = URL.validURLFromString(name) {
+    if let url = URL.validURLFromString(from: name) {
         return AVURLAsset(url: url)
     }
 

Tests/swiftui-loop-videoplayerTests/ext+/testURL.swift

@@ -0,0 +1,94 @@
+//
+//  testURL+.swift
+//  swiftui-loop-videoplayer
+//
+//  Created by Igor Shelopaev on 20.08.25.
+//
+
+import XCTest
+@testable import swiftui_loop_videoplayer
+
+final class testURL: XCTestCase {
+
+    // MARK: - Positive cases (should pass)
+
+    func testSampleVideoURLsPass() {
+        // Given: four sample URLs from the sandbox dictionary
+        let urls = [
+            "https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_ts/master.m3u8",
+            "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+            "https://commondatastorage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4",
+            "https://devstreaming-cdn.apple.com/videos/streaming/examples/adv_dv_atmos/main.m3u8"
+        ]
+
+        // When/Then
+        for raw in urls {
+            let url = URL.validURLFromString(from: raw)
+            XCTAssertNotNil(url, "Expected to parse: \(raw)")
+            XCTAssertEqual(url?.scheme?.lowercased(), "https")
+        }
+    }
+
+    func testAddsHTTPSIfMissing() {
+        // Given
+        let raw = "example.com/path?x=1#y"
+
+        // When
+        let url = URL.validURLFromString(from: raw)
+
+        // Then
+        XCTAssertNotNil(url)
+        XCTAssertEqual(url?.scheme, "https")
+        XCTAssertEqual(url?.host, "example.com")
+        XCTAssertEqual(url?.path, "/path")
+    }
+
+    func testTrimsWhitespace() {
+        let raw = "   https://example.com/video.m3u8   "
+        let url = URL.validURLFromString(from: raw)
+        XCTAssertNotNil(url)
+        XCTAssertEqual(url?.host, "example.com")
+        XCTAssertEqual(url?.path, "/video.m3u8")
+    }
+
+    func testIPv6AndLocalHosts() {
+        // IPv6 loopback
+        XCTAssertNotNil(URL.validURLFromString(from: "https://[::1]"))
+        // localhost
+        XCTAssertNotNil(URL.validURLFromString(from: "http://localhost"))
+        // IPv4 with port and query/fragment
+        XCTAssertNotNil(URL.validURLFromString(from: "http://127.0.0.1:8080/path?a=1#x"))
+    }
+
+    func testIDNUnicodeHost() {
+        // Unicode host (IDN). URLComponents should handle this.
+        let url = URL.validURLFromString(from: "https://bücher.de")
+        XCTAssertNotNil(url)
+        XCTAssertEqual(url?.scheme, "https")
+        XCTAssertNotNil(url?.host)
+    }
+
+    // MARK: - Negative cases (should fail)
+
+    func testRejectsNonHTTP() {
+        XCTAssertNil(URL.validURLFromString(from: "ftp://example.com/file.mp4"))
+        XCTAssertNil(URL.validURLFromString(from: "mailto:user@example.com"))
+        XCTAssertNil(URL.validURLFromString(from: "file:///Users/me/movie.mp4"))
+    }
+
+    func testRejectsInvalidPort() {
+        XCTAssertNil(URL.validURLFromString(from: "https://example.com:0"))
+        XCTAssertNil(URL.validURLFromString(from: "https://example.com:65536"))
+        XCTAssertNotNil(URL.validURLFromString(from: "https://example.com:65535"))
+    }
+
+    func testRejectsMissingHost() {
+        XCTAssertNil(URL.validURLFromString(from: "https://"))
+        XCTAssertNil(URL.validURLFromString(from: "https:///path-only"))
+    }
+
+    func testNoAutoSchemeOption() {
+        // When auto-scheme is disabled, a bare host should fail.
+        XCTAssertNil(URL.validURLFromString(from: "example.com", assumeHTTPSIfMissing: false))
+    }
+}