Scheduler factories

Author: AdamShare

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.5
+// swift-tools-version:5.7
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -34,7 +34,7 @@ let package = Package(
         ),
     ],
     dependencies: [
-        .package(name: "NeedleFoundation", url: "https://github.com/uber/needle.git", .branch("master")),
+        .package(url: "https://github.com/uber/needle.git", branch: "master"),
     ],
     targets: [
         .target(name: "CombineExtensions",
@@ -49,16 +49,18 @@ let package = Package(
                 dependencies: ["Lifecycle"]),
         .testTarget(name: "SPIRTests",
                     dependencies: ["SPIR",
-                                   "NeedleFoundation"]),
+                                   .product(name: "NeedleFoundation", package: "needle")]),
         .target(name: "MVVM",
                 dependencies: ["Lifecycle"]),
         .testTarget(name: "MVVMTests",
                     dependencies: ["MVVM",
-                                   "NeedleFoundation"]),
+                                   .product(name: "NeedleFoundation", package: "needle")]),
         .target(name: "RIBs",
                 dependencies: ["Lifecycle"]),
         .testTarget(name: "RIBsTests",
-                    dependencies: ["RIBs",
-                                   "NeedleFoundation"]),
+                    dependencies: [
+                        "RIBs",
+                                   .product(name: "NeedleFoundation", package: "needle")
+                    ]),
     ]
 )

Sources/CombineExtensions/Schedulers/Dispatch.swift

@@ -31,33 +31,3 @@ public func syncMain<T>(closure: () -> T) -> T {
 public func asyncMain(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
     DispatchQueue.main.async(delay: delay, execute: work)
 }
-
-/// Submits a work item to the userInitiated dispatch queue for asynchronous execution after
-/// a specified time.
-public func asyncUserInitiated(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
-    DispatchQueue.userInitiated.async(delay: delay, execute: work)
-}
-
-/// Submits a work item to the userInteractive dispatch queue for asynchronous execution after
-/// a specified time.
-public func asyncUserInteractive(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
-    DispatchQueue.userInteractive.async(delay: delay, execute: work)
-}
-
-/// Submits a work item to the default dispatch queue for asynchronous execution after
-/// a specified time.
-public func asyncDefault(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
-    DispatchQueue.default.async(delay: delay, execute: work)
-}
-
-/// Submits a work item to the utility dispatch queue for asynchronous execution after
-/// a specified time.
-public func asyncUtility(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
-    DispatchQueue.utility.async(delay: delay, execute: work)
-}
-
-/// Submits a work item to the utility dispatch queue for asynchronous execution after
-/// a specified time.
-public func asyncBackground(delay: TimeInterval = 0, execute work: @escaping () -> Void) {
-    DispatchQueue.background.async(delay: delay, execute: work)
-}

Sources/CombineExtensions/Schedulers/DispatchQueue.swift

@@ -18,29 +18,35 @@ import Combine
 import Foundation
 
 public struct DispatchQueue: DispatchQueueContext, Scheduler {
-
+    static let reverseDNSPrefix = "com.lifecyclekit."
+    
     /// `DispatchQueue.main` underlying queue.
     public static let main = DispatchQueue(backingQueue: Foundation.DispatchQueue.main)
 
-    /// `DispatchQueue.init(qos: .userInteractive)` underlying queue.
-    public static let userInteractive = DispatchQueue(backingQueue: Foundation.DispatchQueue(label: "com.lifecyclekit.userinteractive",
-                                                                                             qos: .userInteractive))
+    /// `DispatchQueue(qos: .userInteractive)` underlying queue.
+    public static func userInteractive(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue {
+        DispatchQueue(label: reverseDNSPrefix + "\(file):\(line)", qualityOfService: .userInteractive)
+    }
 
-    /// `DispatchQueue.init(qos: .userInitiated)` underlying queue.
-    public static let userInitiated = DispatchQueue(backingQueue: Foundation.DispatchQueue(label: "com.lifecyclekit.userInitiated",
-                                                                                           qos: .userInitiated))
+    /// `DispatchQueue(qos: .userInitiated)` underlying queue.
+    public static func userInitiated(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue {
+        DispatchQueue(label: reverseDNSPrefix + "\(file):\(line)", qualityOfService: .userInitiated)
+    }
 
-    /// `DispatchQueue.init(qos: .default)` underlying queue.
-    public static let `default` = DispatchQueue(backingQueue: Foundation.DispatchQueue(label: "com.lifecyclekit.default",
-                                                                                       qos: .default))
+    /// `DispatchQueue(qos: .default)` underlying queue.
+    public static func `default`(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue {
+        DispatchQueue(label: reverseDNSPrefix + "\(file):\(line)", qualityOfService: .default)
+    }
 
-    /// `DispatchQueue.init(qos: .utility)` underlying queue.
-    public static let utility = DispatchQueue(backingQueue: Foundation.DispatchQueue(label: "com.lifecyclekit.utility",
-                                                                                     qos: .utility))
+    /// `DispatchQueue(qos: .utility)` underlying queue.
+    public static func utility(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue {
+        DispatchQueue(label: reverseDNSPrefix + "\(file):\(line)", qualityOfService: .utility)
+    }
 
-    /// `DispatchQueue.init(qos: .background)` underlying queue.
-    public static let background = DispatchQueue(backingQueue: Foundation.DispatchQueue(label: "com.lifecyclekit.background",
-                                                                                        qos: .background))
+    /// `DispatchQueue(qos: .background)` underlying queue.
+    public static func background(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue {
+        DispatchQueue(label: reverseDNSPrefix + "\(file):\(line)", qualityOfService: .background)
+    }
 
     /// The quality of service, or the execution priority, to apply to tasks. From highest (`userInteractive`) to lowest (`background`).
     public enum QualityOfService {

Sources/CombineExtensions/Schedulers/Schedulers.swift

@@ -25,19 +25,24 @@ public enum Schedulers {
     public static var asyncMain: DispatchQueue.Scheduler { .asyncMain }
 
     /// In case `schedule` methods are called from `DispatchQueue.userInteractive`, it will perform action immediately without scheduling.
-    public static var userInteractive: DispatchQueue.Scheduler { .userInteractive }
+    public static func userInteractive(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue.Scheduler {  DispatchQueue.Scheduler.userInteractive(file: file, line: line)
+    }
 
     /// In case `schedule` methods are called from `DispatchQueue.userInitiated`, it will perform action immediately without scheduling.
-    public static var userInitiated: DispatchQueue.Scheduler { .userInitiated }
+    public static func userInitiated(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue.Scheduler { DispatchQueue.Scheduler.userInitiated(file: file, line: line)
+    }
 
     /// In case `schedule` methods are called from `DispatchQueue.default`, it will perform action immediately without scheduling.
-    public static var `default`: DispatchQueue.Scheduler { .default }
+    public static func `default`(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue.Scheduler { DispatchQueue.Scheduler.default(file: file, line: line)
+    }
 
     /// In case `schedule` methods are called from `DispatchQueue.utility`, it will perform action immediately without scheduling.
-    public static var utility: DispatchQueue.Scheduler { .utility }
+    public static func utility(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue.Scheduler { DispatchQueue.Scheduler.utility(file: file, line: line)
+    }
 
     /// In case `schedule` methods are called from `DispatchQueue.background`, it will perform action immediately without scheduling.
-    public static var background: DispatchQueue.Scheduler { .background }
+    public static func background(file: StaticString = #fileID, line: UInt = #line) -> DispatchQueue.Scheduler { DispatchQueue.Scheduler.background(file: file, line: line)
+    }
 }
 
 public extension DispatchQueue {
@@ -51,19 +56,29 @@ public extension DispatchQueue {
         public static let asyncMain: Scheduler = .init(.main, alwaysAsync: true)
 
         /// In case `schedule` methods are called from `DispatchQueue.userInteractive`, it will perform action immediately without scheduling.
-        public static let userInteractive: Scheduler = .init(.userInteractive)
+        public static func userInteractive(file: StaticString = #fileID, line: UInt = #line) -> Scheduler {
+            Scheduler(DispatchQueue.userInteractive(file: file, line: line))
+        }
 
         /// In case `schedule` methods are called from `DispatchQueue.userInitiated`, it will perform action immediately without scheduling.
-        public static let userInitiated: Scheduler = .init(.userInitiated)
+        public static func userInitiated(file: StaticString = #fileID, line: UInt = #line) -> Scheduler {
+            Scheduler(DispatchQueue.userInitiated(file: file, line: line))
+        }
 
         /// In case `schedule` methods are called from `DispatchQueue.default`, it will perform action immediately without scheduling.
-        public static let `default`: Scheduler = .init(.default)
+        public static func `default`(file: StaticString = #fileID, line: UInt = #line) -> Scheduler {
+            Scheduler(DispatchQueue.default(file: file, line: line))
+        }
 
         /// In case `schedule` methods are called from `DispatchQueue.utility`, it will perform action immediately without scheduling.
-        public static let utility: Scheduler = .init(.utility)
+        public static func utility(file: StaticString = #fileID, line: UInt = #line) -> Scheduler {
+            Scheduler(DispatchQueue.utility(file: file, line: line))
+        }
 
         /// In case `schedule` methods are called from `DispatchQueue.background`, it will perform action immediately without scheduling.
-        public static let background: Scheduler = .init(.background)
+        public static func background(file: StaticString = #fileID, line: UInt = #line) -> Scheduler {
+            Scheduler(DispatchQueue.background(file: file, line: line))
+        }
 
         public typealias SchedulerOptions = Never
         public typealias SchedulerTimeType = Foundation.DispatchQueue.SchedulerTimeType

Sources/Lifecycle/Foundation/WeakSet.swift

@@ -20,7 +20,7 @@ import Foundation
 /// - warning: Element must conform to `AnyObject`.
 public struct WeakSet<Element>: ExpressibleByArrayLiteral, CustomDebugStringConvertible {
 
-    private typealias Key = AnyObject
+    private typealias Key = NSNumber
     private typealias Value = AnyObject
 
     /// Returns an array with a strong reference to elements.
@@ -37,7 +37,7 @@ public struct WeakSet<Element>: ExpressibleByArrayLiteral, CustomDebugStringConv
         asArray.count
     }
 
-    private var storage: NSMapTable<Key, Value> = .strongToWeakObjects()
+    private var storage = NSMapTable<Key, Value>.strongToWeakObjects()
 
     public init(arrayLiteral elements: Element...) {
         for element in elements {
@@ -59,11 +59,6 @@ public struct WeakSet<Element>: ExpressibleByArrayLiteral, CustomDebugStringConv
     }
 
     public mutating func formUnion<T>(_ other: WeakSet<T>) {
-        objc_sync_enter(storage); defer { objc_sync_exit(storage) }
-        if !isKnownUniquelyReferenced(&storage) {
-            storage = storageCopy()
-        }
-
         let enumerator = other.storage.objectEnumerator()
         while let object = enumerator?.nextObject() {
             if let object = object as? Element {
@@ -73,36 +68,40 @@ public struct WeakSet<Element>: ExpressibleByArrayLiteral, CustomDebugStringConv
     }
 
     public mutating func insert(_ element: Element) {
-        objc_sync_enter(storage); defer { objc_sync_exit(storage) }
+        copyStorageIfNeeded()
+        insertToStorage(object: element)
+    }
+    
+    private mutating func copyStorageIfNeeded() {
         if !isKnownUniquelyReferenced(&storage) {
-            storage = storageCopy()
+            let copy = NSMapTable<Key, Value>.strongToWeakObjects()
+            for value in storage.dictionaryRepresentation().values {
+                let key = keyForElement(value)
+                copy.setObject(storage.object(forKey: key), forKey: key)
+            }
+            storage = copy
         }
-        insertToStorage(object: element)
     }
 
     private func insertToStorage(object: Element) {
         storage.setObject(object as Value, forKey: keyForElement(object))
     }
 
     public mutating func removeAll() {
-        objc_sync_enter(storage); defer { objc_sync_exit(storage) }
         storage = .strongToWeakObjects()
     }
 
     public mutating func remove(_ element: Element) {
-        objc_sync_enter(storage); defer { objc_sync_exit(storage) }
-        if !isKnownUniquelyReferenced(&storage) {
-            storage = storageCopy()
-        }
+        copyStorageIfNeeded()
         storage.removeObject(forKey: keyForElement(element))
     }
 
     private func keyForElement(_ element: Element) -> Key {
         return NSNumber(value: ObjectIdentifier(element as AnyObject).hashValue)
     }
-
-    private func storageCopy() -> NSMapTable<Key, Value> {
-        storage.copy() as? NSMapTable<Key, Value> ?? .strongToWeakObjects()
+    
+    private func keyForElement<T: AnyObject>(_ element: T) -> Key {
+        return NSNumber(value: ObjectIdentifier(element as AnyObject).hashValue)
     }
 
     public var debugDescription: String {

Sources/Lifecycle/LifecycleSubscriber.swift

@@ -41,6 +41,10 @@ public protocol LifecycleSubscriber: AnyObject {
 public extension ScopeLifecycle {
     /// Binds to lifecycle states receiving on main thread.
     func subscribe(_ subscriber: LifecycleSubscriber) {
+        #if DEBUG
+        assert(Thread.isMainThread, "Subscribe from main thread only.")
+        #endif
+        
         if subscribers.contains(subscriber) {
             assertionFailure("Binding to \(subscriber) that has already been subscribes to. \(subscribers)")
         }

Sources/Lifecycle/View/ViewLifecycleSubscriber.swift

@@ -32,6 +32,10 @@ public protocol ViewLifecycleSubscriber: AnyObject {
 public extension ViewLifecycle {
     /// Binds to lifecycle states receiving on main thread.
     func subscribe(_ subscriber: ViewLifecycleSubscriber) {
+        #if DEBUG
+        assert(Thread.isMainThread, "Subscribe from main thread only.")
+        #endif
+        
         if subscribers.contains(subscriber) {
             assertionFailure("Binding to \(self) that has already been subscribes to. \(subscribers)")
         }

Tests/CombineExtensionsTests/SchedulersTests.swift

@@ -44,26 +44,46 @@ final class SchedulersTests: XCTestCase {
         }
 
         var schedulers: [CombineExtensions.DispatchQueue.Scheduler] = [
-            .userInteractive,
-            .userInitiated,
-            .default,
-            .utility,
-            .background,
+            .userInteractive(),
+            .userInitiated(),
+            .default(),
+            .utility(),
+            .background(),
         ]
         schedulers.forEach(expectSync)
 
         func expectAsync(scheduler: CombineExtensions.DispatchQueue.Scheduler) {
-            var called = false
-            let cancellable = Just(())
-                .receive(on: scheduler)
-                .sink(receiveValue: {
-                    called = true
-                })
-            XCTAssertFalse(called)
-            cancellable.cancel()
+                var called = false
+                let cancellable = Just(())
+                    .receive(on: scheduler)
+                    .sink(receiveValue: {
+                        Thread.sleep(forTimeInterval: 1)
+                        called = true
+                    })
+                XCTAssertFalse(called)
+                cancellable.cancel()
         }
 
         schedulers.append(.asyncMain)
         schedulers.forEach(expectAsync)
     }
+    
+    func testSchedulerConcurrency() {
+        let e = self.expectation(description: "Expect ordered calls to concurrent queue backed scheduler")
+        var values: [Int] = []
+        let startingValues: [Int] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        let cancellable = startingValues
+            .publisher
+            .receive(on: Schedulers.default())
+            .sink(receiveValue: { value in
+                values.append(value)
+                if values.count == 10 {
+                    XCTAssertEqual(startingValues, values)
+                    e.fulfill()
+                }
+            })
+      
+        self.waitForExpectations(timeout: 10.0)
+        cancellable.cancel()
+    }
 }