feat: add equality validation rule

Author: ns-vasilev

README.md

@@ -312,6 +312,7 @@ struct RegistrationView: View {
 | `PositiveNumberValidationRule` | Validates that value is positive | `PositiveNumberValidationRule(error: "Value must be positive")`
 | `NoWhitespaceValidationRule` | Validates that a string does not contain any whitespace characters | `NoWhitespaceValidationRule(error: "Spaces are not allowed")`
 | `ContainsValidationRule` | Validates that a string contains a specific substring | `ContainsValidationRule(substring: "@", error: "Must contain @")`
+| `EqualityValidationRule`| Validates that the input is equal to a given reference value | `EqualityValidationRule(compareTo: password, error: "Passwords do not match")`
 
 ## Custom Validators
 

Sources/ValidatorCore/Classes/Rules/EqualityValidationRule.swift

@@ -0,0 +1,48 @@
+//
+// Validator
+// Copyright © 2025 Space Code. All rights reserved.
+//
+
+/// Validates that the input is equal to a given reference value.
+///
+/// This rule compares the provided `input` against a predefined value using `Equatable`.
+/// Validation passes only if both values are equal.
+///
+/// # Example:
+/// ```swift
+/// let rule = EqualityValidationRule(compareTo: 42, error: SomeError())
+/// rule.validate(input: 42) // true
+/// rule.validate(input: 41) // false
+/// ```
+///
+/// - Note: This rule works with any `Equatable` type.
+public struct EqualityValidationRule<T: Equatable>: IValidationRule {
+    // MARK: Types
+
+    public typealias Input = T
+
+    // MARK: Properties
+
+    public let value: T
+
+    /// The validation error.
+    public let error: IValidationError
+
+    // MARK: Initialization
+
+    /// Creates a validation rule that checks whether the input equals a specific value.
+    ///
+    /// - Parameters:
+    ///   - value: The value to compare the input against.
+    ///   - error: The validation error to return if validation fails.
+    public init(compareTo value: T, error: IValidationError) {
+        self.value = value
+        self.error = error
+    }
+
+    // MARK: IValidationRule
+
+    public func validate(input: T) -> Bool {
+        value == input
+    }
+}

Sources/ValidatorCore/Validator.docc/Overview.md

@@ -35,6 +35,7 @@ ValidatorCore contains all core validation rules, utilities, and mechanisms for
 - ``PositiveNumberValidationRule``
 - ``NoWhitespaceValidationRuleTests``
 - ``ContainsValidationRule``
+- ``EqualityValidationRule``
 
 ### Articles
 

Tests/ValidatorCoreTests/UnitTests/Rules/EqualityValidationRuleTests.swift

@@ -0,0 +1,91 @@
+//
+// Validator
+// Copyright © 2025 Space Code. All rights reserved.
+//
+
+@testable import ValidatorCore
+import XCTest
+
+// MARK: - EqualityValidationRuleTests
+
+final class EqualityValidationRuleTests: XCTestCase {
+    // MARK: Properties
+
+    private var sut: EqualityValidationRule<Int>!
+
+    // MARK: XCTestCase
+
+    override func setUp() {
+        super.setUp()
+        sut = EqualityValidationRule(compareTo: 10, error: String.error)
+    }
+
+    override func tearDown() {
+        sut = nil
+        super.tearDown()
+    }
+
+    // MARK: Tests
+
+    func test_thatValidationRuleSetsProperties() {
+        // then
+        XCTAssertEqual(sut.value, 10)
+        XCTAssertEqual(sut.error.message, .error)
+    }
+
+    func test_thatRuleValidatesCorrectValue() {
+        // when
+        let result = sut.validate(input: 10)
+
+        // then
+        XCTAssertTrue(result)
+    }
+
+    func test_thatRuleFailsForIncorrectValue() {
+        // when
+        let result = sut.validate(input: 5)
+
+        // then
+        XCTAssertFalse(result)
+    }
+
+    func test_thatRuleWorksWithStringInput() {
+        // given
+        let rule = EqualityValidationRule(compareTo: "abc", error: String.error)
+
+        // when
+        let resultPass = rule.validate(input: "abc")
+        let resultFail = rule.validate(input: "abcd")
+
+        // then
+        XCTAssertTrue(resultPass)
+        XCTAssertFalse(resultFail)
+    }
+
+    func test_thatRuleWorksWithCustomEquatableType() {
+        // given
+        struct User: Equatable {
+            let id: Int
+            let name: String
+        }
+
+        let matchUser = User(id: 1, name: "Nikita")
+        let anotherUser = User(id: 2, name: "Alex")
+
+        let rule = EqualityValidationRule(compareTo: matchUser, error: String.error)
+
+        // when
+        let resultPass = rule.validate(input: matchUser)
+        let resultFail = rule.validate(input: anotherUser)
+
+        // then
+        XCTAssertTrue(resultPass)
+        XCTAssertFalse(resultFail)
+    }
+}
+
+// MARK: Constants
+
+private extension String {
+    static let error = "Values must be equal"
+}