Add RFC 1123 implementation and tests

coenttb · claude · coenttb · commit e0f65766b9af · 2025-07-26T17:06:45.000+02:00
🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/Sources/RFC_1123/RFC 1123.swift b/Sources/RFC_1123/RFC 1123.swift
@@ -0,0 +1,229 @@
+//
+//  File.swift
+//  swift-web
+//
+//  Created by Coen ten Thije Boonkkamp on 28/12/2024.
+//
+
+import Foundation
+import RFC_1035
+
+/// RFC 1123 compliant host name
+public struct Domain: Hashable, Sendable {
+    /// The labels that make up the host name, from least significant to most significant
+    private let labels: [Label]
+
+    /// Initialize with an array of string labels, validating RFC 1123 rules
+    public init(labels: [String]) throws {
+        guard !labels.isEmpty else {
+            throw ValidationError.empty
+        }
+
+        guard labels.count <= Limits.maxLabels else {
+            throw ValidationError.tooManyLabels
+        }
+
+        // Validate TLD according to stricter RFC 1123 rules
+        guard let tld = labels.last else {
+            throw ValidationError.empty
+        }
+
+        // Convert and validate labels
+        var validatedLabels = try labels.dropLast().map { label in
+            try Label(label, validateAs: .label)
+        }
+
+        // Add TLD with stricter validation
+        validatedLabels.append(try Label(tld, validateAs: .tld))
+
+        self.labels = validatedLabels
+
+        // Check total length including dots
+        let totalLength = self.name.count
+        guard totalLength <= Limits.maxLength else {
+            throw ValidationError.tooLong(totalLength)
+        }
+    }
+
+    /// Initialize from a string representation (e.g. "host.example.com")
+    public init(_ string: String) throws {
+        try self.init(labels: string.split(separator: ".", omittingEmptySubsequences: true).map(String.init))
+    }
+}
+
+// MARK: - Label Type
+extension Domain {
+    /// A type-safe host label that enforces RFC 1123 rules
+    public struct Label: Hashable, Sendable {
+        enum ValidationType {
+            case label  // Regular label rules
+            case tld    // Stricter TLD rules
+        }
+
+        private let value: String
+
+        /// Initialize a label, validating RFC 1123 rules
+        internal init(_ string: String, validateAs type: ValidationType) throws {
+            guard !string.isEmpty, string.count <= Domain.Limits.maxLabelLength else {
+                throw type == .tld ? Domain.ValidationError.invalidTLD(string) : Domain.ValidationError.invalidLabel(string)
+            }
+
+            let regex = type == .tld ? Domain.tldRegex : Domain.labelRegex
+            guard (try? regex.wholeMatch(in: string)) != nil else {
+                throw type == .tld ? Domain.ValidationError.invalidTLD(string) : Domain.ValidationError.invalidLabel(string)
+            }
+
+            self.value = string
+        }
+
+        public var stringValue: String { value }
+    }
+}
+
+// MARK: - Constants and Validation
+extension Domain {
+    internal enum Limits {
+        static let maxLength = 255
+        static let maxLabels = 127
+        static let maxLabelLength = 63
+    }
+
+    /// RFC 1123 label regex:
+    /// - Can begin with letter or digit
+    /// - Can end with letter or digit
+    /// - May have hyphens in interior positions only
+    nonisolated(unsafe) internal static let labelRegex = /[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?/
+
+    /// RFC 1123 TLD regex:
+    /// - Must begin with a letter
+    /// - Must end with a letter
+    /// - May have hyphens in interior positions only
+    nonisolated(unsafe) internal static let tldRegex = /[a-zA-Z](?:[a-zA-Z0-9\-]*[a-zA-Z])?/
+}
+
+// MARK: - Properties and Methods
+extension Domain {
+    /// The complete host name as a string
+    public var name: String {
+        labels.map(\.stringValue).joined(separator: ".")
+    }
+
+    /// The top-level domain (rightmost label)
+    public var tld: Label? {
+        labels.last
+    }
+
+    /// The second-level domain (second from right)
+    public var sld: Label? {
+        labels.dropLast().last
+    }
+
+    /// Returns true if this is a subdomain of the given host
+    public func isSubdomain(of parent: Domain) -> Bool {
+        guard labels.count > parent.labels.count else { return false }
+        return labels.suffix(parent.labels.count) == parent.labels
+    }
+
+    /// Creates a subdomain by prepending new labels
+    public func addingSubdomain(_ components: [String]) throws -> Domain {
+        try Domain(labels: components + labels.map(\.stringValue))
+    }
+
+    public func addingSubdomain(_ components: String...) throws -> Domain {
+        try self.addingSubdomain(components)
+    }
+
+    /// Returns the parent domain by removing the leftmost label
+    public func parent() throws -> Domain? {
+        guard labels.count > 1 else { return nil }
+        return try Domain(labels: labels.dropFirst().map(\.stringValue))
+    }
+
+    /// Returns the root domain (tld + sld)
+    public func root() throws -> Domain? {
+        guard labels.count >= 2 else { return nil }
+        return try Domain(labels: labels.suffix(2).map(\.stringValue))
+    }
+}
+
+// MARK: - Errors
+extension Domain {
+    public enum ValidationError: Error, LocalizedError, Equatable {
+        case empty
+        case tooLong(_ length: Int)
+        case tooManyLabels
+        case invalidLabel(_ label: String)
+        case invalidTLD(_ tld: String)
+
+        public var errorDescription: String? {
+            switch self {
+            case .empty:
+                return "Host name cannot be empty"
+            case .tooLong(let length):
+                return "Host name length \(length) exceeds maximum of \(Limits.maxLength)"
+            case .tooManyLabels:
+                return "Host name has too many labels (maximum \(Limits.maxLabels))"
+            case .invalidLabel(let label):
+                return "Invalid label '\(label)'. Must start and end with letter/digit, and contain only letters/digits/hyphens"
+            case .invalidTLD(let tld):
+                return "Invalid TLD '\(tld)'. Must start and end with letter, and contain only letters/digits/hyphens"
+            }
+        }
+    }
+}
+
+// MARK: - Convenience Initializers
+extension Domain {
+    /// Creates a host from root level components
+    public static func root(_ sld: String, _ tld: String) throws -> Domain {
+        try Domain(labels: [sld, tld])
+    }
+
+    /// Creates a subdomain with components in most-to-least significant order
+    public static func subdomain(_ components: String...) throws -> Domain {
+        try Domain(labels: components.reversed())
+    }
+}
+
+// MARK: - Protocol Conformances
+extension Domain: CustomStringConvertible {
+    public var description: String { name }
+}
+
+extension Domain: Codable {
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        try container.encode(name)
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        let string = try container.decode(String.self)
+        try self.init(string)
+    }
+}
+
+extension Domain: RawRepresentable {
+    public var rawValue: String { name }
+    public init?(rawValue: String) { try? self.init(rawValue) }
+}
+
+extension RFC_1123.Domain {
+    public init(_ domain: RFC_1035.Domain) throws {
+        self = try RFC_1123.Domain(domain.name)
+    }
+
+    public func toRFC1035() throws -> RFC_1035.Domain {
+        try RFC_1035.Domain(self.name)
+    }
+}
+
+extension RFC_1035.Domain {
+    public init(_ domain: RFC_1123.Domain) throws {
+        try self.init(domain.name)
+    }
+
+    public func toRFC1123() throws -> RFC_1123.Domain {
+        try RFC_1123.Domain(self.name)
+    }
+}
diff --git a/Tests/RFC_1123 Tests/RFC 1123 Tests.swift b/Tests/RFC_1123 Tests/RFC 1123 Tests.swift
@@ -0,0 +1,119 @@
+//
+//  File.swift
+//  swift-web
+//
+//  Created by Coen ten Thije Boonkkamp on 28/12/2024.
+//
+
+import Foundation
+import RFC_1123
+import Testing
+
+@Suite("RFC 1123 Host Tests")
+struct RFC1123Tests {
+    @Test("Successfully creates valid host")
+    func testValidHost() throws {
+        let host = try Domain("host.example.com")
+        #expect(host.name == "host.example.com")
+    }
+
+    @Test("Successfully creates host with numeric labels")
+    func testNumericLabels() throws {
+        let host = try Domain("123.example.com")
+        #expect(host.name == "123.example.com")
+    }
+
+    @Test("Successfully creates host with mixed alphanumeric labels")
+    func testMixedLabels() throws {
+        let host = try Domain("host123.example456.com")
+        #expect(host.name == "host123.example456.com")
+    }
+
+    @Test("Fails with empty host")
+    func testEmptyHost() throws {
+        #expect(throws: Domain.ValidationError.empty) {
+            _ = try Domain("")
+        }
+    }
+
+    @Test("Fails with invalid TLD starting with number")
+    func testInvalidTLDStartingWithNumber() throws {
+        #expect(throws: Domain.ValidationError.invalidTLD("123com")) {
+            _ = try Domain("example.123com")
+        }
+    }
+
+    @Test("Fails with invalid TLD ending with number")
+    func testInvalidTLDEndingWithNumber() throws {
+        #expect(throws: Domain.ValidationError.invalidTLD("com123")) {
+            _ = try Domain("example.com123")
+        }
+    }
+
+    @Test("Fails with invalid label containing special characters")
+    func testInvalidLabelSpecialChars() throws {
+        #expect(throws: Domain.ValidationError.invalidLabel("host@name")) {
+            _ = try Domain("host@name.com")
+        }
+    }
+
+    @Test("Successfully gets TLD")
+    func testTLD() throws {
+        let host = try Domain("example.com")
+        #expect(host.tld?.stringValue == "com")
+    }
+
+    @Test("Successfully gets SLD")
+    func testSLD() throws {
+        let host = try Domain("example.com")
+        #expect(host.sld?.stringValue == "example")
+    }
+
+    @Test("Successfully detects subdomain relationship")
+    func testIsSubdomain() throws {
+        let parent = try Domain("example.com")
+        let child = try Domain("host.example.com")
+        #expect(child.isSubdomain(of: parent))
+    }
+
+    @Test("Successfully adds subdomain")
+    func testAddSubdomain() throws {
+        let host = try Domain("example.com")
+        let subdomain = try host.addingSubdomain("host")
+        #expect(subdomain.name == "host.example.com")
+    }
+
+    @Test("Successfully gets parent domain")
+    func testParentDomain() throws {
+        let host = try Domain("host.example.com")
+        let parent = try host.parent()
+        #expect(parent?.name == "example.com")
+    }
+
+    @Test("Successfully gets root domain")
+    func testRootDomain() throws {
+        let host = try Domain("host.example.com")
+        let root = try host.root()
+        #expect(root?.name == "example.com")
+    }
+
+    @Test("Successfully creates host from root components")
+    func testRootInitializer() throws {
+        let host = try Domain.root("example", "com")
+        #expect(host.name == "example.com")
+    }
+
+    @Test("Successfully creates host from subdomain components")
+    func testSubdomainInitializer() throws {
+        let host = try Domain.subdomain("com", "example", "host")
+        #expect(host.name == "host.example.com")
+    }
+
+    @Test("Successfully encodes and decodes")
+    func testCodable() throws {
+        let original = try Domain("example.com")
+        let encoded = try JSONEncoder().encode(original)
+        let decoded = try JSONDecoder().decode(Domain.self, from: encoded)
+        #expect(original == decoded)
+    }
+}
