Added callback trigger instead of notification based one

Author: Dean151

Sources/RuleKit/Center.swift

@@ -44,7 +44,7 @@ public final class RuleKit {
         }
     }
 
-    var rules: [Notification.Name: any Rule] = [:]
+    var rules: [(rule: any Rule, trigger: any Trigger)] = []
 
     private init() {}
 
@@ -56,24 +56,24 @@ public final class RuleKit {
     }
 
     func triggerFulfilledRules() async throws {
-        for (notification, rule) in rules {
+        for (rule, trigger) in rules {
             guard await rule.isFulfilled else {
                 continue
             }
             let queue = rule.firstOption(ofType: DispatchQueueOption.self)?.queue ?? .main
             queue.async {
-                NotificationCenter.default.post(name: notification, object: nil)
+                trigger.execute()
             }
-            try await store.persist(triggerOf: notification)
+            try await store.persist(triggerOf: trigger)
         }
     }
 
     func donations(for event: Event) async -> Event.Donations {
         (try? await store.donations(for: event)) ?? .empty
     }
 
-    func lastTrigger(for notification: Notification.Name) async -> Date? {
-        try? await store.lastTrigger(of: notification)
+    func lastTrigger(for trigger: any Trigger) async -> Date? {
+        try? await store.lastTrigger(of: trigger)
     }
 
     func donate(_ event: Event) async {
@@ -113,6 +113,14 @@ extension RuleKit {
     }
 
     public static func setRule(triggering notification: Notification.Name, options: [any RuleKitOption] = [], _ rule: Rule) {
-        RuleKit.internal.rules[notification] = options.isEmpty ? rule : RuleWithOptions(options: options, notification: notification, rule: rule)
+        let trigger = NotificationCenterTrigger(notification: notification)
+        let rule = options.isEmpty ? rule : RuleWithOptions(options: options, trigger: trigger, rule: rule)
+        RuleKit.internal.rules.append((rule, trigger))
+    }
+
+    public static func setRule(triggering callback: @escaping @Sendable () -> Void, rawValue: String, options: [any RuleKitOption] = [], _ rule: Rule) {
+        let trigger = CallbackTrigger(rawValue: rawValue, callback: callback)
+        let rule = options.isEmpty ? rule : RuleWithOptions(options: options, trigger: trigger, rule: rule)
+        RuleKit.internal.rules.append((rule, trigger))
     }
 }

Sources/RuleKit/Option.swift

@@ -30,10 +30,10 @@ import Foundation
 public protocol RuleKitOption {
     /// If this returns true, the rule will never be fulfilled, and the notification prevented
     /// Defaults to false
-    func preventRuleFulfillment(for notification: Notification.Name) async -> Bool
+    func preventRuleFulfillment(for trigger: any Trigger) async -> Bool
 }
 extension RuleKitOption {
-    public func preventRuleFulfillment(for notification: Notification.Name) async -> Bool {
+    public func preventRuleFulfillment(for trigger: any Trigger) async -> Bool {
         false
     }
 }
@@ -70,8 +70,8 @@ public struct TriggerFrequencyOption: RuleKitOption {
     let frequency: Frequency
 
     // Thank you, Dave Delong for your thoughtful advices on handling dates at NSSpain XI
-    public func preventRuleFulfillment(for notification: Notification.Name) async -> Bool {
-        guard let lastTrigger = await RuleKit.internal.lastTrigger(for: notification) else {
+    public func preventRuleFulfillment(for trigger: any Trigger) async -> Bool {
+        guard let lastTrigger = await RuleKit.internal.lastTrigger(for: trigger) else {
             return false
         }
         guard let earliestDateForNextRuleTrigger = Calendar.current.date(byAdding: frequency.component, value: 1, to: lastTrigger) else {

Sources/RuleKit/Rule.swift

@@ -117,12 +117,12 @@ extension Rule where Self == AllOfRule {
 
 struct RuleWithOptions: Rule {
     let options: [RuleKitOption]
-    let notification: Notification.Name
+    let trigger: any Trigger
     let rule: Rule
 
     var isFulfilled: Bool {
         get async {
-            for option in options where await option.preventRuleFulfillment(for: notification) {
+            for option in options where await option.preventRuleFulfillment(for: trigger) {
                 return false
             }
             return await rule.isFulfilled

Sources/RuleKit/Store.swift

@@ -83,18 +83,18 @@ extension RuleKit {
             self.url = url
         }
 
-        func lastTrigger(of notification: Notification.Name) throws -> Date? {
+        func lastTrigger(of trigger: any Trigger) throws -> Date? {
             if data == nil {
                 try loadData()
             }
-            return data?.lastTrigger[notification.rawValue]
+            return data?.lastTrigger[trigger.rawValue]
         }
 
-        func persist(triggerOf notification: Notification.Name) throws {
+        func persist(triggerOf trigger: any Trigger) throws {
             if data == nil {
                 try loadData()
             }
-            data?.lastTrigger[notification.rawValue] = Date()
+            data?.lastTrigger[trigger.rawValue] = Date()
             try saveData()
         }
 

Sources/RuleKit/Trigger.swift

@@ -0,0 +1,54 @@
+//
+//  Trigger.swift
+//  RuleKit
+//
+//  MIT License
+//
+//  Copyright (c) 2023 Thomas Durand
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in all
+//  copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+//  SOFTWARE.
+//
+
+import Foundation
+
+public protocol Trigger: Sendable {
+    var rawValue: String { get }
+    func execute()
+}
+
+struct NotificationCenterTrigger: Trigger {
+    let notification: Notification.Name
+
+    var rawValue: String {
+        notification.rawValue
+    }
+
+    func execute() {
+        NotificationCenter.default.post(name: notification, object: nil)
+    }
+}
+
+struct CallbackTrigger: Trigger {
+    let rawValue: String
+    let callback: @Sendable () -> Void
+
+    func execute() {
+        callback()
+    }
+}

Tests/RuleKitTests/RuleKitTests.swift

@@ -28,12 +28,48 @@
 import XCTest
 @testable import RuleKit
 
+extension RuleKit.Event {
+    static let testEvent: Self = "test.event"
+}
+
 final class RuleKitTests: XCTestCase {
-    func testExample() throws {
-        // XCTest Documentation
-        // https://developer.apple.com/documentation/xctest
+    static let testNotification = Notification.Name("test.notification")
+    static let testCallback = "test.callback"
+
+    @MainActor 
+    override class func setUp() {
+        do {
+            try RuleKit.configure(storeLocation: .applicationDefault)
+        } catch {}
+    }
+
+    func testNotificationRuleTriggering() async throws {
+        await RuleKit.Event.testEvent.reset()
+        await RuleKit.setRule(triggering: Self.testNotification, .anyOf {
+            EventRule(event: .testEvent) {
+                $0.donations.count > 0
+            }
+        })
+        let expectation = expectation(forNotification: Self.testNotification, object: nil)
+        await RuleKit.Event.testEvent.donate()
+        await fulfillment(of: [expectation])
+        let count = await RuleKit.Event.testEvent.donations.count
+        XCTAssertEqual(1, count)
+    }
 
-        // Defining Test Cases and Test Methods
-        // https://developer.apple.com/documentation/xctest/defining_test_cases_and_test_methods
+    func testCallbackRuleTriggering() async throws {
+        await RuleKit.Event.testEvent.reset()
+        let expectation = XCTestExpectation()
+        await RuleKit.setRule(triggering: {
+            expectation.fulfill()
+        }, rawValue: Self.testCallback, .anyOf {
+            EventRule(event: .testEvent) {
+                $0.donations.count > 0
+            }
+        })
+        await RuleKit.Event.testEvent.donate()
+        await fulfillment(of: [expectation])
+        let count = await RuleKit.Event.testEvent.donations.count
+        XCTAssertEqual(1, count)
     }
 }