abstract registration function into a protocol

motivation: allow libraries that want to expose the lifecycle so that downstream code could register additional items to do so regardless of the lifecycle backend

changes: abstract registration function into a protocol and conform ComponentLifecycle and ServiceLifecycle to it

Author: tomerd

Sources/Lifecycle/Lifecycle.swift

@@ -194,41 +194,10 @@ extension ServiceLifecycle {
     }
 }
 
-public extension ServiceLifecycle {
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - tasks: one or more `LifecycleTask`.
-    func register(_ tasks: LifecycleTask ...) {
-        self.underlying.register(tasks)
-    }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - tasks: array of `LifecycleTask`.
-    func register(_ tasks: [LifecycleTask]) {
+extension ServiceLifecycle: LifecycleRegistrar {
+    public func register(_ tasks: [LifecycleTask]) {
         self.underlying.register(tasks)
     }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - label: label of the item, useful for debugging.
-    ///    - start: `LifecycleHandler` to perform the startup.
-    ///    - shutdown: `LifecycleHandler` to perform the shutdown.
-    func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
-        self.underlying.register(label: label, start: start, shutdown: shutdown)
-    }
-
-    /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
-    ///
-    /// - parameters:
-    ///    - label: label of the item, useful for debugging.
-    ///    - handler: `LifecycleHandler` to perform the shutdown.
-    func registerShutdown(label: String, _ handler: LifecycleHandler) {
-        self.underlying.registerShutdown(label: label, handler)
-    }
 }
 
 extension ServiceLifecycle {
@@ -480,42 +449,34 @@ public class ComponentLifecycle: LifecycleTask {
     }
 }
 
-public extension ComponentLifecycle {
-    internal struct Task: LifecycleTask {
-        let label: String
-        let start: LifecycleHandler
-        let shutdown: LifecycleHandler
-
-        func start(_ callback: @escaping (Error?) -> Void) {
-            self.start.run(callback)
+extension ComponentLifecycle: LifecycleRegistrar {
+    public func register(_ tasks: [LifecycleTask]) {
+        self.stateLock.withLock {
+            guard case .idle = self.state else {
+                preconditionFailure("invalid state, \(self.state)")
+            }
         }
-
-        func shutdown(_ callback: @escaping (Error?) -> Void) {
-            self.shutdown.run(callback)
+        self.tasksLock.withLock {
+            self.tasks.append(contentsOf: tasks)
         }
     }
+}
 
+public protocol LifecycleRegistrar {
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
-    ///    - tasks: one or more `LifecycleTask`.
-    func register(_ tasks: LifecycleTask ...) {
-        self.register(tasks)
-    }
+    ///    - tasks: array of `LifecycleTask`.
+    func register(_ tasks: [LifecycleTask])
+}
 
+extension LifecycleRegistrar {
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
-    ///    - tasks: array of `LifecycleTask`.
-    func register(_ tasks: [LifecycleTask]) {
-        self.stateLock.withLock {
-            guard case .idle = self.state else {
-                preconditionFailure("invalid state, \(self.state)")
-            }
-        }
-        self.tasksLock.withLock {
-            self.tasks.append(contentsOf: tasks)
-        }
+    ///    - tasks: one or more `LifecycleTask`.
+    public func register(_ tasks: LifecycleTask ...) {
+        self.register(tasks)
     }
 
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
@@ -524,16 +485,30 @@ public extension ComponentLifecycle {
     ///    - label: label of the item, useful for debugging.
     ///    - start: `Handler` to perform the startup.
     ///    - shutdown: `Handler` to perform the shutdown.
-    func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
-        self.register(Task(label: label, start: start, shutdown: shutdown))
+    public func register(label: String, start: LifecycleHandler, shutdown: LifecycleHandler) {
+        self.register(LifecycleTaskImpl(label: label, start: start, shutdown: shutdown))
     }
 
     /// Adds a `LifecycleTask` to a `LifecycleTasks` collection.
     ///
     /// - parameters:
     ///    - label: label of the item, useful for debugging.
     ///    - handler: `Handler` to perform the shutdown.
-    func registerShutdown(label: String, _ handler: LifecycleHandler) {
+    public func registerShutdown(label: String, _ handler: LifecycleHandler) {
         self.register(label: label, start: .none, shutdown: handler)
     }
 }
+
+internal struct LifecycleTaskImpl: LifecycleTask {
+    let label: String
+    let start: LifecycleHandler
+    let shutdown: LifecycleHandler
+
+    func start(_ callback: @escaping (Error?) -> Void) {
+        self.start.run(callback)
+    }
+
+    func shutdown(_ callback: @escaping (Error?) -> Void) {
+        self.shutdown.run(callback)
+    }
+}

Tests/LifecycleTests/ComponentLifecycleTests.swift

@@ -43,16 +43,16 @@ final class ComponentLifecycleTests: XCTestCase {
 
         let items = (1 ... Int.random(in: 10 ... 20)).map { index -> LifecycleTask in
             let id = "item-\(index)"
-            return ComponentLifecycle.Task(label: id,
-                                           start: .sync {
-                                               dispatchPrecondition(condition: .onQueue(.global()))
-                                               startCalls.append(id)
-                                           },
-                                           shutdown: .sync {
-                                               dispatchPrecondition(condition: .onQueue(.global()))
-                                               XCTAssertTrue(startCalls.contains(id))
-                                               stopCalls.append(id)
-                                           })
+            return LifecycleTaskImpl(label: id,
+                                     start: .sync {
+                                         dispatchPrecondition(condition: .onQueue(.global()))
+                                         startCalls.append(id)
+                                     },
+                                     shutdown: .sync {
+                                         dispatchPrecondition(condition: .onQueue(.global()))
+                                         XCTAssertTrue(startCalls.contains(id))
+                                         stopCalls.append(id)
+                                     })
         }
         lifecycle.register(items)
 
@@ -81,16 +81,16 @@ final class ComponentLifecycleTests: XCTestCase {
 
         let items = (1 ... Int.random(in: 10 ... 20)).map { index -> LifecycleTask in
             let id = "item-\(index)"
-            return ComponentLifecycle.Task(label: id,
-                                           start: .sync {
-                                               dispatchPrecondition(condition: .onQueue(testQueue))
-                                               startCalls.append(id)
-                                           },
-                                           shutdown: .sync {
-                                               dispatchPrecondition(condition: .onQueue(testQueue))
-                                               XCTAssertTrue(startCalls.contains(id))
-                                               stopCalls.append(id)
-                                           })
+            return LifecycleTaskImpl(label: id,
+                                     start: .sync {
+                                         dispatchPrecondition(condition: .onQueue(testQueue))
+                                         startCalls.append(id)
+                                     },
+                                     shutdown: .sync {
+                                         dispatchPrecondition(condition: .onQueue(testQueue))
+                                         XCTAssertTrue(startCalls.contains(id))
+                                         stopCalls.append(id)
+                                     })
         }
         lifecycle.register(items)