Add RFC 1035 implementation and tests

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: coenttb

Sources/RFC_1035/RFC 1035.swift

@@ -0,0 +1,179 @@
+//
+//  File.swift
+//  swift-web
+//
+//  Created by Coen ten Thije Boonkkamp on 28/12/2024.
+//
+
+import Foundation
+
+/// RFC 1035 compliant domain name
+public struct Domain: Hashable, Sendable {
+    /// The labels that make up the domain name, from least significant to most significant
+    private let labels: [Label]
+
+    /// Initialize with an array of string labels, validating RFC 1035 rules
+    public init(labels: [String]) throws {
+        guard !labels.isEmpty else {
+            throw ValidationError.empty
+        }
+
+        guard labels.count <= Limits.maxLabels else {
+            throw ValidationError.tooManyLabels
+        }
+
+        // Validate and convert each label
+        self.labels = try labels.map(Label.init)
+
+        // 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. "example.com")
+    public init(_ string: String) throws {
+        try self.init(labels: string.split(separator: ".", omittingEmptySubsequences: true).map(String.init))
+    }
+}
+
+extension Domain {
+    /// A type-safe domain label that enforces RFC 1035 rules
+    public struct Label: Hashable, Sendable {
+        private let value: String
+
+        /// Initialize a label, validating RFC 1035 rules
+        internal init(_ string: String) throws {
+            guard !string.isEmpty, string.count <= Domain.Limits.maxLabelLength else {
+                throw Domain.ValidationError.invalidLabel(string)
+            }
+
+            guard (try? Domain.labelRegex.wholeMatch(in: string)) != nil else {
+                throw Domain.ValidationError.invalidLabel(string)
+            }
+
+            self.value = string
+        }
+
+        public var stringValue: String { value }
+    }
+}
+
+extension Domain {
+    /// The complete domain name as a string
+    public var name: String {
+        labels.map(\.stringValue).joined(separator: ".")
+    }
+
+    /// The top-level domain (rightmost label)
+    public var tld: Domain.Label? {
+        labels.last
+    }
+
+    /// The second-level domain (second from right)
+    public var sld: Domain.Label? {
+        labels.dropLast().last
+    }
+
+    /// Returns true if this is a subdomain of the given domain
+    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: - Constants and Validation
+extension Domain {
+    internal enum Limits {
+        static let maxLength = 255
+        static let maxLabels = 127
+        static let maxLabelLength = 63
+    }
+
+    // RFC 1035 label regex:
+    // - Must begin with a letter
+    // - Must end with a letter or digit
+    // - May have hyphens in interior positions only
+    nonisolated(unsafe) internal static let labelRegex = /[a-zA-Z](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?/
+}
+
+// MARK: - Errors
+extension Domain {
+    public enum ValidationError: Error, LocalizedError, Equatable {
+        case empty
+        case tooLong(_ length: Int)
+        case tooManyLabels
+        case invalidLabel(_ label: String)
+
+        public var errorDescription: String? {
+            switch self {
+            case .empty:
+                return "Domain name cannot be empty"
+            case .tooLong(let length):
+                return "Domain name length \(length) exceeds maximum of \(Limits.maxLength)"
+            case .tooManyLabels:
+                return "Domain name has too many labels (maximum \(Limits.maxLabels))"
+            case .invalidLabel(let label):
+                return "Invalid label '\(label)'. Must start with letter, end with letter/digit, and contain only letters/digits/hyphens"
+            }
+        }
+    }
+}
+
+// MARK: - Convenience Initializers
+extension Domain {
+    /// Creates a domain 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) }
+}

Tests/RFC_1035 Tests/RFC 1035 Tests.swift

@@ -0,0 +1,123 @@
+//
+//  File.swift
+//  swift-web
+//
+//  Created by Coen ten Thije Boonkkamp on 28/12/2024.
+//
+
+import Foundation
+import RFC_1035
+import Testing
+
+@Suite("RFC 1035 Domain Tests")
+struct RFC1035Tests {
+    @Test("Successfully creates valid domain")
+    func testValidDomain() throws {
+        let domain = try Domain("example.com")
+        #expect(domain.name == "example.com")
+    }
+
+    @Test("Successfully creates subdomain")
+    func testValidSubdomain() throws {
+        let domain = try Domain("sub.example.com")
+        #expect(domain.name == "sub.example.com")
+    }
+
+    @Test("Successfully gets TLD")
+    func testTLD() throws {
+        let domain = try Domain("example.com")
+        #expect(domain.tld?.stringValue == "com")
+    }
+
+    @Test("Successfully gets SLD")
+    func testSLD() throws {
+        let domain = try Domain("example.com")
+        #expect(domain.sld?.stringValue == "example")
+    }
+
+    @Test("Fails with empty domain")
+    func testEmptyDomain() throws {
+        #expect(throws: Domain.ValidationError.empty) {
+            _ = try Domain("")
+        }
+    }
+
+    @Test("Fails with too many labels")
+    func testTooManyLabels() throws {
+        let longDomain = Array(repeating: "a", count: 128).joined(separator: ".")
+        #expect(throws: Domain.ValidationError.tooManyLabels) {
+            _ = try Domain(longDomain)
+        }
+    }
+
+    @Test("Fails with too long domain")
+    func testTooLongDomain() throws {
+        let longLabel = String(repeating: "a", count: 63)
+        let longDomain = Array(repeating: longLabel, count: 5).joined(separator: ".")
+        #expect(throws: Domain.ValidationError.tooLong(319)) {
+            _ = try Domain(longDomain)
+        }
+    }
+
+    @Test("Fails with invalid label starting with hyphen")
+    func testInvalidLabelStartingWithHyphen() throws {
+        #expect(throws: Domain.ValidationError.invalidLabel("-example")) {
+            _ = try Domain("-example.com")
+        }
+    }
+
+    @Test("Fails with invalid label ending with hyphen")
+    func testInvalidLabelEndingWithHyphen() throws {
+        #expect(throws: Domain.ValidationError.invalidLabel("example-")) {
+            _ = try Domain("example-.com")
+        }
+    }
+
+    @Test("Successfully detects subdomain relationship")
+    func testIsSubdomain() throws {
+        let parent = try Domain("example.com")
+        let child = try Domain("sub.example.com")
+        #expect(child.isSubdomain(of: parent))
+    }
+
+    @Test("Successfully adds subdomain")
+    func testAddSubdomain() throws {
+        let domain = try Domain("example.com")
+        let subdomain = try domain.addingSubdomain("sub")
+        #expect(subdomain.name == "sub.example.com")
+    }
+
+    @Test("Successfully gets parent domain")
+    func testParentDomain() throws {
+        let domain = try Domain("sub.example.com")
+        let parent = try domain.parent()
+        #expect(parent?.name == "example.com")
+    }
+
+    @Test("Successfully gets root domain")
+    func testRootDomain() throws {
+        let domain = try Domain("sub.example.com")
+        let root = try domain.root()
+        #expect(root?.name == "example.com")
+    }
+
+    @Test("Successfully creates domain from root components")
+    func testRootInitializer() throws {
+        let domain = try Domain.root("example", "com")
+        #expect(domain.name == "example.com")
+    }
+
+    @Test("Successfully creates domain from subdomain components")
+    func testSubdomainInitializer() throws {
+        let domain = try Domain.subdomain("com", "example", "sub")
+        #expect(domain.name == "sub.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)
+    }
+}