feat: add base64 validation rule (#115)

Author: ns-vasilev

README.md

@@ -317,6 +317,7 @@ struct RegistrationView: View {
 | `IBANValidationRule` | Validates that a string is a valid IBAN (International Bank Account Number) | `IBANValidationRule(error: "Invalid IBAN")`
 | `IPAddressValidationRule` | Validates that a string is a valid IPv4 or IPv6 address | `IPAddressValidationRule(version: .v4, error: ValidationError("Invalid IPv4"))`
 | `PostalCodeValidationRule` | Validates postal/ZIP codes for different countries | `PostalCodeValidationRule(country: .uk, error: "Invalid post code")`
+| `Base64ValidationRule` | | `Base64ValidationRule(error: "The input is not valid Base64.")`
 
 ## Custom Validators
 

Sources/ValidatorCore/Classes/Rules/Base64ValidationRule.swift

@@ -0,0 +1,52 @@
+//
+// Validator
+// Copyright © 2026 Space Code. All rights reserved.
+//
+
+import Foundation
+
+/// Validates that a string represents valid Base64-encoded data.
+///
+/// # Example:
+/// ```swift
+/// let rule = Base64ValidationRule(error: "Invalid Base64")
+/// rule.validate(input: "SGVsbG8gV29ybGQ=") // true
+/// rule.validate(input: "not_base64!") // false
+/// ```
+public struct Base64ValidationRule: IValidationRule {
+    // MARK: Types
+
+    public typealias Input = String
+
+    // MARK: Properties
+
+    /// The validation error returned if the input is not valid Base64.
+    public let error: IValidationError
+
+    // MARK: Initialization
+
+    /// Initializes a Base64 validation rule.
+    ///
+    /// - Parameter error: The validation error returned if input fails validation.
+    public init(error: IValidationError) {
+        self.error = error
+    }
+
+    // MARK: IValidationRule
+
+    public func validate(input: String) -> Bool {
+        guard !input.isEmpty else { return false }
+
+        let cleanedInput = input.replacingOccurrences(of: "\\s", with: "", options: .regularExpression)
+
+        guard !cleanedInput.isEmpty else { return false }
+
+        guard cleanedInput.count.isMultiple(of: 4) else { return false }
+
+        guard Data(base64Encoded: cleanedInput) != nil else { return false }
+
+        let base64Pattern = "^[A-Za-z0-9+/]*={0,2}$"
+        let predicate = NSPredicate(format: "SELF MATCHES %@", base64Pattern)
+        return predicate.evaluate(with: cleanedInput)
+    }
+}

Sources/ValidatorCore/Validator.docc/Overview.md

@@ -40,6 +40,7 @@ ValidatorCore contains all core validation rules, utilities, and mechanisms for
 - ``IBANValidationRule``
 - ``IPAddressValidationRule``
 - ``PostalCodeValidationRule``
+- ``Base64ValidationRule``
 
 ### Articles
 

Tests/ValidatorCoreTests/UnitTests/Rules/Base64ValidationRuleTests.swift

@@ -0,0 +1,189 @@
+//
+// Validator
+// Copyright © 2026 Space Code. All rights reserved.
+//
+
+import ValidatorCore
+import XCTest
+
+// MARK: - Base64ValidationRuleTests
+
+final class Base64ValidationRuleTests: XCTestCase {
+    // MARK: - Properties
+
+    private var sut: Base64ValidationRule!
+
+    // MARK: - Setup
+
+    override func setUp() {
+        super.setUp()
+        sut = Base64ValidationRule(error: String.error)
+    }
+
+    override func tearDown() {
+        sut = nil
+        super.tearDown()
+    }
+
+    // MARK: - Tests
+
+    func test_validate_validBase64_shouldReturnTrue() {
+        // given
+        let base64 = "SGVsbG8gV29ybGQ="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_validBase64WithoutPadding_shouldReturnTrue() {
+        // given
+        let base64 = "SGVsbG8="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_validBase64NoPadding_shouldReturnTrue() {
+        // given
+        let base64 = "YWJj"
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_validBase64WithPlus_shouldReturnTrue() {
+        // given
+        let base64 = "YWJjZGVmZ2hpamts+A=="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_validBase64WithSlash_shouldReturnTrue() {
+        // given
+        let base64 = "YWJjZGVmZ2hpamts/w=="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_invalidCharacters_shouldReturnFalse() {
+        // given
+        let base64 = "Hello@World!"
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_invalidLength_shouldReturnFalse() {
+        // given
+        let base64 = "SGVsbG"
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_tooManyPaddingCharacters_shouldReturnFalse() {
+        // given
+        let base64 = "SGVsbG8==="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_emptyString_shouldReturnFalse() {
+        // given
+        let base64 = ""
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_whitespaceString_shouldReturnFalse() {
+        // given
+        let base64 = "    "
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_plainText_shouldReturnFalse() {
+        // given
+        let base64 = "not base64"
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_validate_base64WithWhitespace_shouldReturnTrue() {
+        // given
+        let base64 = "SGVs bG8g V29y bGQ="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_base64WithNewlines_shouldReturnTrue() {
+        // given
+        let base64 = "SGVs\nbG8g\nV29y\nbGQ="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_validate_paddingInMiddle_shouldReturnFalse() {
+        // given
+        let base64 = "SGVs=bG8="
+
+        // when
+        let result = sut.validate(input: base64)
+
+        // then
+        XCTAssertFalse(result)
+    }
+}
+
+// MARK: Constants
+
+private extension String {
+    static let error = "Base64 string is invalid"
+}