Add CreditCardValidationRule implementation (#26)

* Add `CreditCardValidationRule` implementation

* Write unit tests for `CreditCardValidationRule`

* Update `README.md`

* Update `CHANGELOG.md`

Author: ns-vasilev

CHANGELOG.md

@@ -13,6 +13,8 @@ All notable changes to this project will be documented in this file.
   - Added in Pull Request [#21](https://github.com/space-code/validator/pull/21).
 - Add `URLValidationRule`.
   - Added in Pull Request [#25](https://github.com/space-code/validator/pull/25).
+- Add `CreditCardValidationRule`.
+  - Added in Pull Request [#26](https://github.com/space-code/validator/pull/26).
 
 #### Updated
 - Update `Mintfile`

README.md

@@ -200,6 +200,7 @@ struct ContentView: View {
 | **SuffixValidationRule**   | To validate whether a string contains a suffix                                      |
 | **RegexValidationRule**    | To validate if a pattern is matched                                                 |
 | **URLValidationRule**      | To validate whether a string contains a URL                                         |
+| **CreditCardValidationRule** | To validate whether a string has a valid credit card number                       |
 
 ## Custom Validation Rules
 

Sources/ValidatorCore/Classes/Rules/CreditCardValidationRule.swift

@@ -0,0 +1,76 @@
+//
+// Validator
+// Copyright © 2025 Space Code. All rights reserved.
+//
+
+/// A credit card validation rule.
+public struct CreditCardValidationRule: IValidationRule {
+    // MARK: Types
+
+    public enum CardType: String, Sendable, CaseIterable {
+        case visa, masterCard, amex, jcb, unionPay
+    }
+
+    public typealias Input = String
+
+    // MARK: Properties
+
+    public let types: [CardType]
+
+    /// The validation error.
+    public let error: IValidationError
+
+    // MARK: Initialization
+
+    public init(types: [CardType] = CardType.allCases, error: IValidationError) {
+        self.types = types
+        self.error = error
+    }
+
+    // MARK: IValidationRule
+
+    public func validate(input: String) -> Bool {
+        let sanitized = input.replacingOccurrences(of: " ", with: "")
+
+        guard sanitized.allSatisfy(\.isNumber) else { return false }
+
+        guard types.contains(where: { matches(cardNumber: sanitized, type: $0) }) else { return false }
+
+        return isValidLuhn(sanitized)
+    }
+
+    // MARK: Private
+
+    private func matches(cardNumber: String, type: CardType) -> Bool {
+        switch type {
+        case .visa:
+            cardNumber.hasPrefix("4") && (cardNumber.count == 13 || cardNumber.count == 16 || cardNumber.count == 19)
+        case .masterCard:
+            (cardNumber.hasPrefix("51") || cardNumber.hasPrefix("52") ||
+                cardNumber.hasPrefix("53") || cardNumber.hasPrefix("54") ||
+                cardNumber.hasPrefix("55")) && cardNumber.count == 16
+        case .amex:
+            (cardNumber.hasPrefix("34") || cardNumber.hasPrefix("37")) && cardNumber.count == 15
+        case .jcb:
+            (cardNumber.hasPrefix("3528") || cardNumber.hasPrefix("3589")) && cardNumber.count == 16
+        case .unionPay:
+            cardNumber.hasPrefix("62") && (cardNumber.count >= 16 && cardNumber.count <= 19)
+        }
+    }
+
+    private func isValidLuhn(_ cardNumber: String) -> Bool {
+        let reversedDigits = cardNumber.reversed().map { Int(String($0)) ?? 0 }
+        var sum = 0
+
+        for (index, digit) in reversedDigits.enumerated() {
+            if !index.isMultiple(of: 2) {
+                let doubled = digit * 2
+                sum += doubled > 9 ? doubled - 9 : doubled
+            } else {
+                sum += digit
+            }
+        }
+
+        return sum.isMultiple(of: 10)
+    }
+}

Tests/ValidatorCoreTests/UnitTests/Rules/CreditCardValidationRuleTests.swift

@@ -0,0 +1,164 @@
+//
+// Validator
+// Copyright © 2025 Space Code. All rights reserved.
+//
+
+@testable import ValidatorCore
+import XCTest
+
+// MARK: - CreditCardValidationRuleTests
+
+final class CreditCardValidationRuleTests: XCTestCase {
+    // MARK: - Visa
+
+    func test_validate_visaCardValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.visa], error: String.error)
+        let validVisa = "4111111111111111"
+
+        // when
+        let isValid = rule.validate(input: validVisa)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    func test_validate_visaCardInvalid_shouldReturnFalse() {
+        // given
+        let rule = CreditCardValidationRule(types: [.visa], error: String.error)
+        let invalidVisa = "411111111111112"
+
+        // when
+        let isValid = rule.validate(input: invalidVisa)
+
+        // then
+        XCTAssertFalse(isValid)
+    }
+
+    // MARK: - MasterCard
+
+    func test_validate_masterCardValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.masterCard], error: String.error)
+        let validMaster = "5500000000000004"
+
+        // when
+        let isValid = rule.validate(input: validMaster)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    func test_validate_masterCardInvalid_shouldReturnFalse() {
+        // given
+        let rule = CreditCardValidationRule(types: [.masterCard], error: String.error)
+        let invalidMaster = "550000000000"
+
+        // when
+        let isValid = rule.validate(input: invalidMaster)
+
+        // then
+        XCTAssertFalse(isValid)
+    }
+
+    // MARK: - American Express
+
+    func test_validate_amexValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.amex], error: String.error)
+        let validAmex = "340000000000009"
+
+        // when
+        let isValid = rule.validate(input: validAmex)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    func test_validate_amexInvalid_shouldReturnFalse() {
+        // given
+        let rule = CreditCardValidationRule(types: [.amex], error: String.error)
+        let invalidAmex = "3400000000000099"
+
+        // when
+        let isValid = rule.validate(input: invalidAmex)
+
+        // then
+        XCTAssertFalse(isValid)
+    }
+
+    // MARK: - JCB
+
+    func test_validate_jcbValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.jcb], error: String.error)
+        let validJCB = "3528000000000007"
+
+        // when
+        let isValid = rule.validate(input: validJCB)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    // MARK: - UnionPay
+
+    func test_validate_unionPayValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.unionPay], error: String.error)
+        let validUnionPay = "6221260000000000"
+
+        // when
+        let isValid = rule.validate(input: validUnionPay)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    // MARK: - Multiple Types
+
+    func test_validate_multipleTypesValid_shouldReturnTrue() {
+        // given
+        let rule = CreditCardValidationRule(types: [.visa, .amex, .masterCard], error: String.error)
+        let validVisa = "4111111111111111"
+
+        // when
+        let isValid = rule.validate(input: validVisa)
+
+        // then
+        XCTAssertTrue(isValid)
+    }
+
+    // MARK: - Unknown Card Type
+
+    func test_validate_unknownCardType_shouldReturnFalse() {
+        // given
+        let rule = CreditCardValidationRule(types: [.visa], error: String.error)
+        let randomCard = "9999999999999999"
+
+        // when
+        let isValid = rule.validate(input: randomCard)
+
+        // then
+        XCTAssertFalse(isValid)
+    }
+
+    // MARK: - Empty Input
+
+    func test_validate_emptyString_shouldReturnFalse() {
+        // given
+        let rule = CreditCardValidationRule(types: [.visa], error: String.error)
+
+        // when
+        let isValid = rule.validate(input: "")
+
+        // then
+        XCTAssertFalse(isValid)
+    }
+}
+
+// MARK: Constants
+
+private extension String {
+    static let error = "Invalid card number"
+}