@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/Combine/Helpers/ConduitBase.swift

@@ -0,0 +1,40 @@
+//
+//  ConduitBase.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.06.2020.
+//
+
+internal class ConduitBase<Output, Failure: Error>: Subscription {
+
+    internal init() {}
+
+    internal func offer(_ output: Output) {
+        abstractMethod()
+    }
+
+    internal func finish(completion: Subscribers.Completion<Failure>) {
+        abstractMethod()
+    }
+
+    internal func request(_ demand: Subscribers.Demand) {
+        abstractMethod()
+    }
+
+    internal func cancel() {
+        abstractMethod()
+    }
+}
+
+extension ConduitBase: Equatable {
+    internal static func == (lhs: ConduitBase<Output, Failure>,
+                             rhs: ConduitBase<Output, Failure>) -> Bool {
+        return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
+    }
+}
+
+extension ConduitBase: Hashable {
+    internal func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(self))
+    }
+}

package/Sources/Combine/Helpers/ConduitList.swift

@@ -0,0 +1,59 @@
+//
+//  ConduitList.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 25.06.2020.
+//
+
+internal enum ConduitList<Output, Failure: Error> {
+    case empty
+    case single(ConduitBase<Output, Failure>)
+    case many(Set<ConduitBase<Output, Failure>>)
+}
+
+extension ConduitList: HasDefaultValue {
+    init() {
+        self = .empty
+    }
+}
+
+extension ConduitList {
+    internal mutating func insert(_ conduit: ConduitBase<Output, Failure>) {
+        switch self {
+        case .empty:
+            self = .single(conduit)
+        case .single(conduit):
+            break // This element already exists.
+        case .single(let existingConduit):
+            self = .many([existingConduit, conduit])
+        case .many(var set):
+            set.insert(conduit)
+            self = .many(set)
+        }
+    }
+
+    internal func forEach(
+        _ body: (ConduitBase<Output, Failure>) throws -> Void
+    ) rethrows {
+        switch self {
+        case .empty:
+            break
+        case .single(let conduit):
+            try body(conduit)
+        case .many(let set):
+            try set.forEach(body)
+        }
+    }
+
+    internal mutating func remove(_ conduit: ConduitBase<Output, Failure>) {
+        switch self {
+        case .single(conduit):
+            self = .empty
+        case .empty, .single:
+            break
+        case .many(var set):
+            set.remove(conduit)
+            self = .many(set)
+        }
+    }
+}

package/Sources/Combine/Helpers/DebugHook.swift

@@ -0,0 +1,177 @@
+//
+//  DebugHook.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 27.09.2020.
+//
+
+internal final class DebugHook {
+
+    private struct Handler: Hashable {
+        let handler: _Introspection
+
+        static func == (lhs: Handler, rhs: Handler) -> Bool {
+            return lhs.handler === rhs.handler
+        }
+
+        func hash(into hasher: inout Hasher) {
+            hasher.combine(ObjectIdentifier(handler))
+        }
+    }
+
+    internal static func getGlobalHook() -> DebugHook? {
+        globalLock.lock()
+        defer { globalLock.unlock() }
+        return globalHook
+    }
+
+    internal static func enable(_ handler: _Introspection) {
+        let hook: DebugHook
+        DebugHook.globalLock.lock()
+        defer { DebugHook.globalLock.unlock() }
+        if let _hook = DebugHook.globalHook {
+            hook = _hook
+        } else {
+            hook = DebugHook()
+            DebugHook.globalHook = hook
+        }
+        hook.lock.lock()
+        defer { hook.lock.unlock() }
+        hook.handlers.insert(Handler(handler: handler))
+    }
+
+    internal static func disable(_ handler: _Introspection) {
+        DebugHook.globalLock.lock()
+        defer { DebugHook.globalLock.unlock() }
+        guard let hook = DebugHook.globalHook else { return }
+        hook.lock.lock()
+        hook.handlers.remove(Handler(handler: handler))
+        let noMoreHandlers = hook.handlers.isEmpty
+        hook.lock.unlock()
+        if noMoreHandlers {
+            DebugHook.globalHook = nil
+        }
+    }
+
+    internal static func handlerIsEnabled(_ handler: _Introspection) -> Bool {
+        DebugHook.globalLock.lock()
+        defer { DebugHook.globalLock.unlock() }
+        guard let hook = DebugHook.globalHook else { return false }
+        hook.lock.lock()
+        defer { hook.lock.unlock() }
+        return hook.handlers.contains(Handler(handler: handler))
+    }
+
+    private static var globalHook: DebugHook?
+
+    private static let globalLock = UnfairLock.allocate()
+
+    private let lock = UnfairLock.allocate()
+
+    private var handlers = Set<Handler>()
+
+    internal var debugHandlers: [_Introspection] {
+        lock.lock()
+        defer { lock.unlock() }
+        return handlers.map { $0.handler }
+    }
+
+    private init() {}
+
+    deinit {
+        lock.deallocate()
+    }
+
+    internal func willReceive<Upstream: Publisher, Downstream: Subscriber>(
+        publisher: Upstream,
+        subscriber: Downstream
+    ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input {
+        for debugHandler in debugHandlers {
+            debugHandler.willReceive(publisher: publisher, subscriber: subscriber)
+        }
+    }
+
+    internal func didReceive<Upstream: Publisher, Downstream: Subscriber>(
+        publisher: Upstream,
+        subscriber: Downstream
+    ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input {
+        for debugHandler in debugHandlers {
+            debugHandler.didReceive(publisher: publisher, subscriber: subscriber)
+        }
+    }
+
+    internal func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                      subscription: Subscription) {
+        for debugHandler in debugHandlers {
+            debugHandler.willReceive(subscriber: subscriber, subscription: subscription)
+        }
+    }
+
+    internal func didReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                     subscription: Subscription) {
+        for debugHandler in debugHandlers {
+            debugHandler.didReceive(subscriber: subscriber, subscription: subscription)
+        }
+    }
+
+    internal func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                      input: Downstream.Input) {
+        for debugHandler in debugHandlers {
+            debugHandler.willReceive(subscriber: subscriber, input: input)
+        }
+    }
+
+    internal func didReceive<Downstream: Subscriber>(
+        subscriber: Downstream,
+        input: Downstream.Input,
+        resultingDemand: Subscribers.Demand
+    ) {
+        for debugHandler in debugHandlers {
+            debugHandler.didReceive(subscriber: subscriber,
+                                    input: input,
+                                    resultingDemand: resultingDemand)
+        }
+    }
+
+    internal func willReceive<Downstream: Subscriber>(
+        subscriber: Downstream,
+        completion: Subscribers.Completion<Downstream.Failure>
+    ) {
+        for debugHandler in debugHandlers {
+            debugHandler.willReceive(subscriber: subscriber, completion: completion)
+        }
+    }
+
+    internal func didReceive<Downstream: Subscriber>(
+        subscriber: Downstream,
+        completion: Subscribers.Completion<Downstream.Failure>
+    ) {
+        for debugHandler in debugHandlers {
+            debugHandler.didReceive(subscriber: subscriber, completion: completion)
+        }
+    }
+
+    internal func willRequest(subscription: Subscription, demand: Subscribers.Demand) {
+        for debugHandler in debugHandlers {
+            debugHandler.willRequest(subscription: subscription, demand)
+        }
+    }
+
+    internal func didRequest(subscription: Subscription, demand: Subscribers.Demand) {
+        for debugHandler in debugHandlers {
+            debugHandler.didRequest(subscription: subscription, demand)
+        }
+    }
+
+    internal func willCancel(subscription: Subscription) {
+        for debugHandler in debugHandlers {
+            debugHandler.willCancel(subscription: subscription)
+        }
+    }
+
+    internal func didCancel(subscription: Subscription) {
+        for debugHandler in debugHandlers {
+            debugHandler.didCancel(subscription: subscription)
+        }
+    }
+}

package/Sources/Combine/Helpers/FilterProducer.swift

@@ -0,0 +1,174 @@
+//
+//  FilterProducer.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 23.10.2019.
+//
+
+/// A helper class that acts like both subscriber and subscription.
+///
+/// Filter-like operators send an instance of their `Inner` class that is subclass
+/// of this class to the upstream publisher (as subscriber) and
+/// to the downstream subscriber (as subscription).
+///
+/// Filter-like operators include `Publishers.Filter`,
+/// `Publishers.RemoveDuplicates`, `Publishers.PrefixWhile` and more.
+///
+/// Subclasses must override the `receive(newValue:)` and `description`.
+internal class FilterProducer<Downstream: Subscriber,
+                              Input,
+                              Output,
+                              UpstreamFailure: Error,
+                              Filter>
+    : CustomStringConvertible,
+      CustomReflectable
+    where Downstream.Input == Output
+{
+    // MARK: - State
+
+    private enum State {
+        case awaitingSubscription
+        case connected(Subscription)
+        case completed
+    }
+
+    internal final let filter: Filter
+
+    internal final let downstream: Downstream
+
+    private let lock = UnfairLock.allocate()
+
+    private var state = State.awaitingSubscription
+
+    internal init(downstream: Downstream, filter: Filter) {
+        self.downstream = downstream
+        self.filter = filter
+    }
+
+    deinit {
+        lock.deallocate()
+    }
+
+    // MARK: - Abstract methods
+
+    internal func receive(
+        newValue: Input
+    ) -> PartialCompletion<Output?, Downstream.Failure> {
+        abstractMethod()
+    }
+
+    internal var description: String {
+        abstractMethod()
+    }
+
+    // MARK: - CustomReflectable
+
+    internal var customMirror: Mirror {
+        let children = CollectionOfOne<Mirror.Child>(("downstream", downstream))
+        return Mirror(self, children: children)
+    }
+}
+
+extension FilterProducer: Subscriber {
+
+    internal func receive(subscription: Subscription) {
+        lock.lock()
+        guard case .awaitingSubscription = state else {
+            lock.unlock()
+            subscription.cancel()
+            return
+        }
+        state = .connected(subscription)
+        lock.unlock()
+        downstream.receive(subscription: self)
+    }
+
+    internal func receive(_ input: Input) -> Subscribers.Demand {
+        lock.lock()
+        switch state {
+        case .awaitingSubscription:
+            lock.unlock()
+            fatalError("Invalid state: Received value before receiving subscription")
+        case .completed:
+            lock.unlock()
+        case let .connected(subscription):
+            lock.unlock()
+            switch receive(newValue: input) {
+            case let .continue(output?):
+                return downstream.receive(output)
+            case .continue(nil):
+                return .max(1)
+            case .finished:
+                lock.lock()
+                state = .completed
+                lock.unlock()
+                subscription.cancel()
+                downstream.receive(completion: .finished)
+            case let .failure(error):
+                lock.lock()
+                state = .completed
+                lock.unlock()
+                subscription.cancel()
+                downstream.receive(completion: .failure(error))
+            }
+        }
+
+        return .none
+    }
+
+    internal func receive(completion: Subscribers.Completion<UpstreamFailure>) {
+        lock.lock()
+        switch state {
+        case .awaitingSubscription:
+            lock.unlock()
+            fatalError("Invalid state: Received completion before receiving subscription")
+        case .completed:
+            lock.unlock()
+            return
+        case .connected:
+            state = .completed
+            lock.unlock()
+            switch completion {
+            case .finished:
+                downstream.receive(completion: .finished)
+            case let .failure(failure):
+                downstream.receive(completion: .failure(failure as! Downstream.Failure))
+            }
+        }
+    }
+}
+
+extension FilterProducer: Subscription {
+
+    internal func request(_ demand: Subscribers.Demand) {
+        demand.assertNonZero()
+        lock.lock()
+        switch state {
+        case .awaitingSubscription:
+            lock.unlock()
+            fatalError("Invalid state: Received request before sending subscription")
+        case .completed:
+            lock.unlock()
+            return
+        case let .connected(subscription):
+            lock.unlock()
+            subscription.request(demand)
+        }
+    }
+
+    internal func cancel() {
+        lock.lock()
+        guard case let .connected(subscription) = state else {
+            state = .completed
+            lock.unlock()
+            return
+        }
+        state = .completed
+        lock.unlock()
+        subscription.cancel()
+    }
+}
+
+extension FilterProducer: CustomPlaygroundDisplayConvertible {
+    internal var playgroundDescription: Any { return description }
+}

package/Sources/Combine/Helpers/Locking.swift

@@ -0,0 +1,30 @@
+//
+//  Locking.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 11.06.2019.
+//
+
+#if canImport(COpenCombineHelpers)
+import COpenCombineHelpers
+#endif
+
+#if WASI
+internal struct __UnfairLock { // swiftlint:disable:this type_name
+    internal static func allocate() -> UnfairLock { return .init() }
+    internal func lock() {}
+    internal func unlock() {}
+    internal func assertOwner() {}
+    internal func deallocate() {}
+}
+
+internal struct __UnfairRecursiveLock { // swiftlint:disable:this type_name
+    internal static func allocate() -> UnfairRecursiveLock { return .init() }
+    internal func lock() {}
+    internal func unlock() {}
+    internal func deallocate() {}
+}
+#endif // WASI
+
+internal typealias UnfairLock = __UnfairLock
+internal typealias UnfairRecursiveLock = __UnfairRecursiveLock

package/Sources/Combine/Helpers/PartialCompletion.swift

@@ -0,0 +1,26 @@
+//
+//  PartialCompletion.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 22.09.2019.
+//
+
+/// A value of this type is returned by the overridden `receive(newValue:)` method
+/// of the `ReduceProducer` and `FilterProducer` classes.
+internal enum PartialCompletion<Value, Failure: Error> {
+
+    /// Indicate that we should continue accepting the upstream's output.
+    case `continue`(Value)
+
+    /// Indicate that no values should be received from the upstream anymore.
+    case finished
+
+    /// Indicate that there was a failure and we should send it downstream.
+    case failure(Failure)
+}
+
+extension PartialCompletion where Value == Void {
+
+    /// Indicate that we should continue accepting the upstream's output.
+    internal static var `continue`: PartialCompletion { return .continue(()) }
+}