@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/Publishers/Publishers.Print.swift

@@ -0,0 +1,206 @@
+//
+//  Publishers.Print.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 16.06.2019.
+//
+
+extension Publisher {
+
+    /// Prints log messages for all publishing events.
+    ///
+    /// Use `print(_:to:)` to log messages the console.
+    ///
+    /// In the example below, log messages are printed on the console:
+    ///
+    ///     let integers = (1...2)
+    ///     cancellable = integers.publisher
+    ///        .print("Logged a message", to: nil)
+    ///        .sink { _ in }
+    ///
+    ///     // Prints:
+    ///     //  Logged a message: receive subscription: (1..<2)
+    ///     //  Logged a message: request unlimited
+    ///     //  Logged a message: receive value: (1)
+    ///     //  Logged a message: receive finished
+    ///
+    /// - Parameters:
+    ///   - prefix: A string — which defaults to empty — with which to prefix all log
+    ///     messages.
+    ///   - stream: A stream for text output that receives messages, and which directs
+    ///     output to the console by default.  A custom stream can be used to log messages
+    ///     to other destinations.
+    /// - Returns: A publisher that prints log messages for all publishing events.
+    public func print(_ prefix: String = "",
+                      to stream: TextOutputStream? = nil) -> Publishers.Print<Self> {
+        return .init(upstream: self, prefix: prefix, to: stream)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that prints log messages for all publishing events, optionally
+    /// prefixed with a given string.
+    ///
+    /// This publisher prints log messages when receiving the following events:
+    ///
+    /// - subscription
+    /// - value
+    /// - normal completion
+    /// - failure
+    /// - cancellation
+    public struct Print<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// A string with which to prefix all log messages.
+        public let prefix: String
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        public let stream: TextOutputStream?
+
+        /// Creates a publisher that prints log messages for all publishing events.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher from which this publisher receives elements.
+        ///   - prefix: A string with which to prefix all log messages.
+        public init(upstream: Upstream,
+                    prefix: String,
+                    to stream: TextOutputStream? = nil) {
+            self.upstream = upstream
+            self.prefix = prefix
+            self.stream = stream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Failure == Downstream.Failure, Output == Downstream.Input
+        {
+            let inner = Inner(downstream: subscriber, prefix: prefix, stream: stream)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.Print {
+    private final class Inner<Downstream: Subscriber>: Subscriber,
+                                                       Subscription,
+                                                       CustomStringConvertible,
+                                                       CustomReflectable,
+                                                       CustomPlaygroundDisplayConvertible
+    {
+        typealias Input = Downstream.Input
+        typealias Failure = Downstream.Failure
+
+        /// A concrete type wrapper around an abstract stream.
+        private struct PrintTarget: TextOutputStream {
+
+            var stream: TextOutputStream
+
+            mutating func write(_ string: String) {
+                stream.write(string)
+            }
+        }
+
+        private var downstream: Downstream
+        private let prefix: String
+        private var stream: PrintTarget?
+        private var status = SubscriptionStatus.awaitingSubscription
+        private let lock = UnfairLock.allocate()
+
+        init(downstream: Downstream, prefix: String, stream: TextOutputStream?) {
+            self.downstream = downstream
+            self.prefix = prefix.isEmpty ? "" : "\(prefix): "
+            self.stream = stream.map(PrintTarget.init)
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            log("\(prefix)receive subscription: (\(subscription))")
+            lock.lock()
+            guard case .awaitingSubscription = status else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            status = .subscribed(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            log("\(prefix)receive value: (\(input))")
+            let demand = downstream.receive(input)
+
+            if let max = demand.max {
+                log("\(prefix)request max: (\(max)) (synchronous)")
+            } else {
+                log("\(prefix)request unlimited (synchronous)")
+            }
+
+            return demand
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            switch completion {
+            case .finished:
+                log("\(prefix)receive finished")
+            case .failure(let error):
+                log("\(prefix)receive error: (\(error))")
+            }
+            lock.lock()
+            status = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            if let max = demand.max {
+                log("\(prefix)request max: (\(max))")
+            } else {
+                log("\(prefix)request unlimited")
+            }
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            log("\(prefix)receive cancel")
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "Print" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+
+        // MARK: - Private
+
+        private func log(_ text: String) {
+            if var stream = stream {
+                Swift.print(text, to: &stream)
+            } else {
+                Swift.print(text)
+            }
+        }
+    }
+}

package/Sources/Combine/Publishers/Publishers.ReceiveOn.swift

@@ -0,0 +1,227 @@
+//
+//  Publishers.ReceiveOn.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 02.12.2019.
+//
+
+extension Publisher {
+    /// Specifies the scheduler on which to receive elements from the publisher.
+    ///
+    /// You use the `receive(on:options:)` operator to receive results and completion on
+    /// a specific scheduler, such as performing UI work on the main run loop. In contrast
+    /// with `subscribe(on:options:)`, which affects upstream messages,
+    /// `receive(on:options:)` changes the execution context of downstream messages.
+    ///
+    /// In the following example, the `subscribe(on:options:)` operator causes
+    /// `jsonPublisher` to receive requests on `backgroundQueue`, while
+    /// the `receive(on:options:)` causes `labelUpdater` to receive elements and
+    /// completion on `RunLoop.main`.
+    ///
+    ///     // Some publisher.
+    ///     let jsonPublisher = MyJSONLoaderPublisher()
+    ///
+    ///     // Some subscriber that updates the UI.
+    ///     let labelUpdater = MyLabelUpdateSubscriber()
+    ///
+    ///     jsonPublisher
+    ///         .subscribe(on: backgroundQueue)
+    ///         .receive(on: RunLoop.main)
+    ///         .subscribe(labelUpdater)
+    ///
+    ///
+    /// Prefer `receive(on:options:)` over explicit use of dispatch queues when performing
+    /// work in subscribers. For example, instead of the following pattern:
+    ///
+    ///     pub.sink {
+    ///         DispatchQueue.main.async {
+    ///             // Do something.
+    ///         }
+    ///     }
+    ///
+    /// Use this pattern instead:
+    ///
+    ///     pub.receive(on: DispatchQueue.main).sink {
+    ///         // Do something.
+    ///     }
+    ///
+    ///  > Note: `receive(on:options:)` doesn’t affect the scheduler used to cal
+    ///  the subscriber’s `receive(subscription:)` method.
+    ///
+    /// - Parameters:
+    ///   - scheduler: The scheduler the publisher uses for element delivery.
+    ///   - options: Scheduler options used to customize element delivery.
+    /// - Returns: A publisher that delivers elements using the specified scheduler.
+    public func receive<Context: Scheduler>(
+        on scheduler: Context,
+        options: Context.SchedulerOptions? = nil
+    ) -> Publishers.ReceiveOn<Self, Context> {
+        return .init(upstream: self, scheduler: scheduler, options: options)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that delivers elements to its downstream subscriber on a specific
+    /// scheduler.
+    public struct ReceiveOn<Upstream: Publisher, Context: Scheduler>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The scheduler the publisher is to use for element delivery.
+        public let scheduler: Context
+
+        /// Scheduler options that customize the delivery of elements.
+        public let options: Context.SchedulerOptions?
+
+        public init(upstream: Upstream,
+                    scheduler: Context,
+                    options: Context.SchedulerOptions?) {
+            self.upstream = upstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            let inner = Inner(scheduler: scheduler,
+                              options: options,
+                              downstream: subscriber)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.ReceiveOn {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+        typealias Failure = Upstream.Failure
+
+        private let lock = UnfairLock.allocate()
+        private let downstream: Downstream
+        private let scheduler: Context
+        private let options: Context.SchedulerOptions?
+        private var state = SubscriptionStatus.awaitingSubscription
+        private let downstreamLock = UnfairRecursiveLock.allocate()
+
+        init(scheduler: Context,
+             options: Context.SchedulerOptions?,
+             downstream: Downstream) {
+            self.downstream = downstream
+            self.scheduler = scheduler
+            self.options = options
+        }
+
+        deinit {
+            lock.deallocate()
+            downstreamLock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = state else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            state = .subscribed(subscription)
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(subscription: self)
+            downstreamLock.unlock()
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = state else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.scheduledReceive(input)
+            }
+            return .none
+        }
+
+        private func scheduledReceive(_ input: Input) {
+            lock.lock()
+            guard state.subscription != nil else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            downstreamLock.lock()
+            let newDemand = downstream.receive(input)
+            downstreamLock.unlock()
+            if newDemand == .none { return }
+            lock.lock()
+            let subscription = state.subscription
+            lock.unlock()
+            subscription?.request(newDemand)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .pendingTerminal(subscription)
+            lock.unlock()
+            scheduler.schedule(options: options) {
+                self.scheduledReceive(completion: completion)
+            }
+        }
+
+        private func scheduledReceive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            state = .terminal
+            lock.unlock()
+            downstreamLock.lock()
+            downstream.receive(completion: completion)
+            downstreamLock.unlock()
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "ReceiveOn" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Publishers.Reduce.swift

@@ -0,0 +1,204 @@
+//
+//  Publishers.Reduce.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 09.10.2019.
+//
+
+extension Publisher {
+
+    /// Applies a closure that collects each element of a stream and publishes a final
+    /// result upon completion.
+    ///
+    /// Use `reduce(_:_:)` to collect a stream of elements and produce an accumulated
+    /// value based on a closure you provide.
+    ///
+    /// In the following example, the `reduce(_:_:)` operator collects all the integer
+    /// values it receives from its upstream publisher:
+    ///
+    ///     let numbers = (0...10)
+    ///     cancellable = numbers.publisher
+    ///         .reduce(0, { accum, next in accum + next })
+    ///         .sink { print("\($0)") }
+    ///
+    ///     // Prints: "55"
+    ///
+    /// - Parameters:
+    ///   - initialResult: The value that the closure receives the first time it’s called.
+    ///   - nextPartialResult: A closure that produces a new value by taking
+    ///     the previously-accumulated value and the next element it receives from
+    ///     the upstream publisher.
+    /// - Returns: A publisher that applies the closure to all received elements and
+    ///   produces an accumulated value when the upstream publisher finishes.
+    ///   If `reduce(_:_:)` receives an error from the upstream publisher, the operator
+    ///   delivers it to the downstream subscriber, the publisher terminates and publishes
+    ///   no value.
+    public func reduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: @escaping (Accumulator, Output) -> Accumulator
+    ) -> Publishers.Reduce<Self, Accumulator> {
+        return .init(upstream: self,
+                     initial: initialResult,
+                     nextPartialResult: nextPartialResult)
+    }
+
+    /// Applies an error-throwing closure that collects each element of a stream and
+    /// publishes a final result upon completion.
+    ///
+    /// Use `tryReduce(_:_:)` to collect a stream of elements and produce an accumulated
+    /// value based on an error-throwing closure you provide.
+    /// If the closure throws an error, the publisher fails and passes the error to its
+    /// subscriber.
+    ///
+    /// In the example below, the publisher’s `0` element causes the `myDivide(_:_:)`
+    /// function to throw an error and publish the `Double.nan` result:
+    ///
+    ///     struct DivisionByZeroError: Error {}
+    ///     func myDivide(_ dividend: Double, _ divisor: Double) throws -> Double {
+    ///         guard divisor != 0 else { throw DivisionByZeroError() }
+    ///         return dividend / divisor
+    ///     }
+    ///
+    ///     var numbers: [Double] = [5, 4, 3, 2, 1, 0]
+    ///     numbers.publisher
+    ///         .tryReduce(numbers.first!, { accum, next in try myDivide(accum, next) })
+    ///         .catch({ _ in Just(Double.nan) })
+    ///         .sink { print("\($0)") }
+    ///
+
+    /// - Parameters:
+    ///   - initialResult: The value that the closure receives the first time it’s called.
+    ///   - nextPartialResult: An error-throwing closure that takes
+    ///     the previously-accumulated value and the next element from the upstream
+    ///     publisher to produce a new value.
+    ///
+    /// - Returns: A publisher that applies the closure to all received elements and
+    ///   produces an accumulated value when the upstream publisher finishes.
+    public func tryReduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: @escaping (Accumulator, Output) throws -> Accumulator
+    ) -> Publishers.TryReduce<Self, Accumulator> {
+        return .init(upstream: self,
+                     initial: initialResult,
+                     nextPartialResult: nextPartialResult)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that applies a closure to all received elements and produces
+    /// an accumulated value when the upstream publisher finishes.
+    public struct Reduce<Upstream: Publisher, Output>: Publisher {
+
+        public typealias Failure = Upstream.Failure
+
+        public let upstream: Upstream
+
+        /// The initial value provided on the first invocation of the closure.
+        public let initial: Output
+
+        /// A closure that takes the previously-accumulated value and the next element
+        /// from the upstream publisher to produce a new value.
+        public let nextPartialResult: (Output, Upstream.Output) -> Output
+
+        public init(upstream: Upstream,
+                    initial: Output,
+                    nextPartialResult: @escaping (Output, Upstream.Output) -> Output) {
+            self.upstream = upstream
+            self.initial = initial
+            self.nextPartialResult = nextPartialResult
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Upstream.Failure == Downstream.Failure
+        {
+            let inner = Inner(downstream: subscriber,
+                              initial: initial,
+                              reduce: nextPartialResult)
+            upstream.subscribe(inner)
+        }
+    }
+
+    /// A publisher that applies an error-throwing closure to all received elements and
+    /// produces an accumulated value when the upstream publisher finishes.
+    public struct TryReduce<Upstream: Publisher, Output>: Publisher {
+
+        public typealias Failure = Error
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The initial value provided on the first invocation of the closure.
+        public let initial: Output
+
+        /// An error-throwing closure that takes the previously-accumulated value and
+        /// the next element from the upstream to produce a new value.
+        ///
+        /// If this closure throws an error, the publisher fails and passes the error
+        /// to its subscriber.
+        public let nextPartialResult: (Output, Upstream.Output) throws -> Output
+
+        public init(
+            upstream: Upstream,
+            initial: Output,
+            nextPartialResult: @escaping (Output, Upstream.Output) throws -> Output
+        ) {
+            self.upstream = upstream
+            self.initial = initial
+            self.nextPartialResult = nextPartialResult
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Downstream.Failure == Error
+        {
+            let inner = Inner(downstream: subscriber,
+                              initial: initial,
+                              reduce: nextPartialResult)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.Reduce {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Output,
+                         Upstream.Failure,
+                         (Output, Upstream.Output) -> Output>
+        where Downstream.Input == Output, Upstream.Failure == Downstream.Failure
+    {
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            result = reduce(result!, newValue)
+            return .continue
+        }
+
+        override var description: String { return "Reduce" }
+    }
+}
+
+extension Publishers.TryReduce {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Output,
+                         Upstream.Failure,
+                         (Output, Upstream.Output) throws -> Output>
+        where Downstream.Input == Output, Downstream.Failure == Error
+    {
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            do {
+                result = try reduce(result!, newValue)
+                return .continue
+            } catch {
+                return .failure(error)
+            }
+        }
+
+        override var description: String { return "TryReduce" }
+    }
+}