21 · URL과 URLComponents

let value = "던킨&도너츠"
let naive = "https://api.example.com/search?q=\(value)"
let url = URL(string: naive)!                 // 성공한다 — nil이 아니다
let parsed = URLComponents(url: url, resolvingAgainstBaseURL: false)
print(url.absoluteString)
// https://api.example.com/search?q=%EB%8D%98%ED%82%A8&%EB%8F%84%EB%84%88%EC%B8%A0
print(parsed?.queryItems?.map { "\($0.name)=\($0.value ?? "")" } ?? [])
// ["q=던킨", "도너츠="]  <- q 값이 "던킨"에서 끊기고, "도너츠"가 새 파라미터 이름으로 주입됐다

func searchURL(keyword: String, sort: String) -> URL? {
    var comps = URLComponents(string: "https://api.example.com/search")!
    comps.queryItems = [
        URLQueryItem(name: "q", value: keyword),
        URLQueryItem(name: "sort", value: sort)
    ]
    return comps.url
}

// ❌ 나쁜 예 — 검색어에 &, =, 한글이 섞이면 그대로 오염된다
func searchURLNaive(keyword: String) -> URL? {
    URL(string: "https://api.example.com/search?q=\(keyword)")
}

func appendingTracking(to url: URL, campaign: String) -> URL? {
    guard var comps = URLComponents(url: url, resolvingAgainstBaseURL: false) else { return nil }
    var items = comps.queryItems ?? []
    items.append(URLQueryItem(name: "utm_campaign", value: campaign))
    comps.queryItems = items
    return comps.url
}

var comps = URLComponents(string: "https://api.example.com/search")!
comps.queryItems = [URLQueryItem(name: "q", value: "1+1=2")]
print(comps.percentEncodedQuery!)
// q=1+1%3D2   <- "=" 는 %3D로 인코딩됐지만 "+" 는 그대로 남았다

// urlQueryAllowed로 "값 하나"를 인코딩하면 &, = 를 놓친다(위험)
let dangerous = "a&b=c".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
print(dangerous)   // a&b=c  <- 하나도 안 바뀜, 여전히 파라미터 인젝션에 노출

var valueAllowed = CharacterSet.urlQueryAllowed
valueAllowed.remove(charactersIn: "+&=")   // 값 안에 있으면 안 되는 구분자 후보를 직접 제거

let encoded = "1+1=2".addingPercentEncoding(withAllowedCharacters: valueAllowed)!
print(encoded)   // 1%2B1%3D2  <- + 와 = 모두 인코딩됨

var comps2 = URLComponents(string: "https://api.example.com/search")!
comps2.percentEncodedQuery = "q=\(encoded)"
print(comps2.url!.absoluteString)
// https://api.example.com/search?q=1%2B1%3D2

extension String {
    /// 쿼리 "값" 하나를 안전하게 percent-encode한다 (전체 쿼리 문자열용 CharacterSet과는 다르다)
    var percentEncodedQueryValue: String {
        var allowed = CharacterSet.urlQueryAllowed
        allowed.remove(charactersIn: "+&=")
        return addingPercentEncoding(withAllowedCharacters: allowed) ?? self
    }
}
print("1+1=2".percentEncodedQueryValue)   // 1%2B1%3D2

// ❌ percentEncodedQueryValue 라는 프로퍼티는 존재하지 않는다.
//    x-www-form-urlencoded 는 허용 문자 집합을 직접 만들어야 한다.
private let formAllowed: CharacterSet = {
    var cs = CharacterSet.alphanumerics
    cs.insert(charactersIn: "-._* ")   // 공백은 일단 통과시킨 뒤 '+'로 치환한다
    return cs
}()

func formURLEncodedBody(_ params: [String: String]) -> Data {
    let pairs = params.map { key, value -> String in
        let k = key.addingPercentEncoding(withAllowedCharacters: formAllowed)!
            .replacingOccurrences(of: " ", with: "+")
        let v = value.addingPercentEncoding(withAllowedCharacters: formAllowed)!
            .replacingOccurrences(of: " ", with: "+")
        return "\(k)=\(v)"
    }
    return pairs.joined(separator: "&").data(using: .utf8)!
}

// 실행 결과 (Swift 6.2.1 실측)
let body = formURLEncodedBody(["검색어": "맛집 추천", "q": "a+b&c"])
print(String(data: body, encoding: .utf8)!)
// %EA%B2%80%EC%83%89%EC%96%B4=%EB%A7%9B%EC%A7%91+%EC%B6%94%EC%B2%9C&q=a%2Bb%26c
//                                              ↑ 공백은 +        ↑ 리터럴 +는 %2B, &는 %26

let fileURL = URL(fileURLWithPath: "/Users/kim/문서 폴더/report.pdf")
print(fileURL.path)
// /Users/kim/문서 폴더/report.pdf   <- 그대로 쓸 수 있는 파일시스템 경로
print(fileURL.absoluteString)
// file:///Users/kim/%E1%84%86%E1%85%AE%E1%86%AB%E1%84%89%E1%85%A5%20%E1%84%91%E1%85%A9%E1%86%AF%E1%84%83%E1%85%A5/report.pdf

let base = URL(string: "https://example.com/docs/")!
let rel = URL(string: "guide.html?x=1", relativeTo: base)!

print(rel.path)            // /docs/guide.html   <- base까지 합쳐진 절대 경로
print(rel.relativePath)    // guide.html          <- 문자열 그대로 준 상대 부분만
print(rel.absoluteString)  // https://example.com/docs/guide.html?x=1
print(rel.absoluteURL.path)// /docs/guide.html    <- .path와 동일

if #available(macOS 13, *) {
    print(rel.path(percentEncoded: true))   // /docs/guide.html
    print(rel.path(percentEncoded: false))  // /docs/guide.html (이 예시엔 인코딩 대상 문자가 없어 동일)
}

func fileExists(at url: URL) -> Bool {
    // ✅ path — 순수 파일시스템 경로
    FileManager.default.fileExists(atPath: url.path)
}

func brokenFileExists(at url: URL) -> Bool {
    // ❌ absoluteString에는 "file://" 스킴이 붙어 있어 그대로 넘기면 항상 false
    FileManager.default.fileExists(atPath: url.absoluteString)
}

func logRequest(_ url: URL) {
    // ✅ 스킴, 쿼리, 프래그먼트까지 다 포함된 전체 URL
    print("요청: \(url.absoluteString)")
}

let inputs = ["my string", "https://x.com/a b", "https://x.com/한글경로", "a|b", "a^b"]
for s in inputs {
    print(s, "->")
    print("  기본:", URL(string: s)?.absoluteString ?? "nil")
    print("  false:", URL(string: s, encodingInvalidCharacters: false)?.absoluteString ?? "nil")
    print("  true:", URL(string: s, encodingInvalidCharacters: true)?.absoluteString ?? "nil")
}

let input = "https://example.org?url=https%3A%2F%2Fy.org%3Ffoo[0]%3Dbar"
let u = URL(string: input)!
print(u.absoluteString)
// https://example.org?url=https%253A%252F%252Fy.org%253Ffoo%5B0%5D%253Dbar
// 대괄호는 정상적으로 %5B / %5D 가 됐지만,
// 원래 있던 %3A / %2F 는 %253A / %252F 로 "% 기호까지" 다시 인코딩돼버렸다

func strictURL(from raw: String) -> URL? {
    // false — 자동 보정 없이 RFC 3986 위반이면 바로 nil
    URL(string: raw, encodingInvalidCharacters: false)
}

if strictURL(from: userTypedURLString) == nil {
    // 자동으로 고쳐질 걸 기대하지 말고 여기서 사용자에게 즉시 피드백
}

func wrappingRedirect(target: URL, into base: URL) -> URL? {
    guard var comps = URLComponents(url: base, resolvingAgainstBaseURL: false) else { return nil }
    var items = comps.queryItems ?? []
    // ✅ queryItems가 target.absoluteString을 안전하게 한 번만 인코딩한다
    items.append(URLQueryItem(name: "url", value: target.absoluteString))
    comps.queryItems = items
    return comps.url
}

var url = tmpDir.appendingPathComponent("test.txt")
try "hello".write(to: url, atomically: true, encoding: .utf8)

var v = URLResourceValues()
v.isExcludedFromBackup = true
try url.setResourceValues(v)   // url이 var여야 하는 이유 — 내부 캐시가 갱신된다

let readBack = try url.resourceValues(forKeys: [
    .fileSizeKey, .isExcludedFromBackupKey, .creationDateKey, .isDirectoryKey
])
print(readBack.fileSize!)               // 5
print(readBack.isExcludedFromBackup!)   // true
print(readBack.creationDate != nil)     // true
print(readBack.isDirectory!)            // false

func excludeFromBackup(_ fileURL: URL) throws {
    var url = fileURL
    var values = URLResourceValues()
    values.isExcludedFromBackup = true
    try url.setResourceValues(values)
}
// 호출부: Caches 디렉터리에 새로 쓴 파일에만 적용
try excludeFromBackup(cachesDirectory.appendingPathComponent("thumbnail.jpg"))

func fileSnapshot(_ url: URL) throws -> (size: Int, modified: Date?) {
    let v = try url.resourceValues(forKeys: [.fileSizeKey, .contentModificationDateKey])
    return (v.fileSize ?? 0, v.contentModificationDate)
}