@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/Combine/Publishers/Publishers.Retry.swift

@@ -0,0 +1,274 @@
+//
+//  Publishers.Retry.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 28.06.2020.
+//
+
+extension Publisher {
+
+    /// Attempts to recreate a failed subscription with the upstream publisher up to
+    /// the number of times you specify.
+    ///
+    /// Use `retry(_:)` to try connecting to an upstream publisher after a failed
+    /// connection attempt.
+    ///
+    /// In the example below, a `URLSession.DataTaskPublisher` attempts to connect to
+    /// a remote URL. If the connection attempt succeeds, it publishes the remote
+    /// service’s HTML to the downstream publisher and completes normally. Otherwise,
+    /// the retry operator attempts to reestablish the connection. If after three attempts
+    /// the publisher still can’t connect to the remote URL, the `catch(_:)` operator
+    /// replaces the error with a new publisher that publishes a “connection timed out”
+    /// HTML page. After the downstream subscriber receives the timed out message,
+    /// the stream completes normally.
+    ///
+    ///     struct WebSiteData: Codable {
+    ///         var rawHTML: String
+    ///     }
+    ///
+    ///     let myURL = URL(string: "https://www.example.com")
+    ///
+    ///     cancellable = URLSession.shared.dataTaskPublisher(for: myURL!)
+    ///         .retry(3)
+    ///         .map { page -> WebSiteData in
+    ///             WebSiteData(rawHTML: String(decoding: page.data, as: UTF8.self))
+    ///         }
+    ///         .catch { error in
+    ///             Just(
+    ///                 WebSiteData(
+    ///                     rawHTML: "<HTML>Unable to load page - timed out.</HTML>"
+    ///                 )
+    ///             )
+    ///         }
+    ///         .sink(receiveCompletion: { print ("completion: \($0)") },
+    ///               receiveValue: { print ("value: \($0)") })
+    ///
+    ///     // Prints: The HTML content from the remote URL upon a successful connection,
+    ///     //         or returns "<HTML>Unable to load page - timed out.</HTML>" if
+    ///     //         the number of retries exceeds the specified value.
+    ///
+    /// After exceeding the specified number of retries, the publisher passes the failure
+    /// to the downstream receiver.
+    /// - Parameter retries: The number of times to attempt to recreate the subscription.
+    /// - Returns: A publisher that attempts to recreate its subscription to a failed
+    ///   upstream publisher.
+    public func retry(_ retries: Int) -> Publishers.Retry<Self> {
+        return .init(upstream: self, retries: retries)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that attempts to recreate its subscription to a failed upstream
+    /// publisher.
+    public struct Retry<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The maximum number of retry attempts to perform.
+        ///
+        /// If `nil`, this publisher attempts to reconnect with the upstream publisher
+        /// an unlimited number of times.
+        public let retries: Int?
+
+        /// Creates a publisher that attempts to recreate its subscription to a failed
+        /// upstream publisher.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher from which this publisher receives its elements.
+        ///   - retries: The maximum number of retry attempts to perform. If `nil`, this
+        ///     publisher attempts to reconnect with the upstream publisher an unlimited
+        ///     number of times.
+        public init(upstream: Upstream, retries: Int?) {
+            self.upstream = upstream
+            self.retries = retries
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Input == Output, Downstream.Failure == Failure
+        {
+            upstream.subscribe(Inner(parent: self, downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.Retry: Equatable where Upstream: Equatable {}
+
+extension Publishers.Retry {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Failure == Failure, Downstream.Input == Output
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private enum State {
+            case ready(Publishers.Retry<Upstream>, Downstream)
+            case terminal
+        }
+
+        private enum Chances {
+            case finite(Int)
+            case infinite
+        }
+
+        private let lock = UnfairLock.allocate()
+
+        private var state: State
+
+        private var upstreamSubscription: Subscription?
+
+        private var remaining: Chances
+
+        private var downstreamNeedsSubscription = true
+
+        private var downstreamDemand = Subscribers.Demand.none
+
+        private var completionRecursion = false
+
+        private var needsSubscribe = false
+
+        init(parent: Publishers.Retry<Upstream>, downstream: Downstream) {
+            state = .ready(parent, downstream)
+            remaining = parent.retries.map(Chances.finite) ?? .infinite
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case let .ready(_, downstream) = state, upstreamSubscription == nil
+            else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            upstreamSubscription = subscription
+            let downstreamDemand = self.downstreamDemand
+            let downstreamNeedsSubscription = self.downstreamNeedsSubscription
+            self.downstreamNeedsSubscription = false
+            lock.unlock()
+            if downstreamNeedsSubscription {
+                downstream.receive(subscription: self)
+            }
+            if downstreamDemand != .none {
+                subscription.request(downstreamDemand)
+            }
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case let .ready(_, downstream) = state else {
+                lock.unlock()
+                return .none
+            }
+            downstreamDemand -= 1
+            lock.unlock()
+
+            let newDemand = downstream.receive(input)
+
+            if newDemand == .none { return .none }
+
+            lock.lock()
+            downstreamDemand += newDemand
+
+            if let upstreamSubscription = self.upstreamSubscription {
+                lock.unlock()
+                upstreamSubscription.request(newDemand)
+            } else {
+                lock.unlock()
+            }
+
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            guard case let .ready(parent, downstream) = state else {
+                lock.unlock()
+                return
+            }
+
+            if case .failure = completion {
+                upstreamSubscription = nil
+                switch remaining {
+                case .finite(0):
+                    break
+                case .finite(let attempts):
+                    remaining = .finite(attempts - 1)
+                    fallthrough
+                case .infinite:
+                    if completionRecursion {
+                        needsSubscribe = true
+                        lock.unlock()
+                        return
+                    }
+                    repeat {
+                        completionRecursion = true
+                        needsSubscribe = false
+                        lock.unlock()
+                        parent.upstream.subscribe(self)
+                        lock.lock()
+                        completionRecursion = false
+                    } while needsSubscribe
+                    lock.unlock()
+                    return
+                }
+            }
+
+            state = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case .ready = state else {
+                lock.unlock()
+                return
+            }
+            downstreamDemand += demand
+            if let upstreamSubscription = self.upstreamSubscription {
+                lock.unlock()
+                upstreamSubscription.request(demand)
+            } else {
+                lock.unlock()
+            }
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case .ready = state else {
+                lock.unlock()
+                return
+            }
+            state = .terminal
+            if let upstreamSubscription = self.upstreamSubscription {
+                lock.unlock()
+                upstreamSubscription.cancel()
+            } else {
+                lock.unlock()
+            }
+        }
+
+        var description: String { return "Retry" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/Publishers/Publishers.Scan.swift

@@ -0,0 +1,331 @@
+//
+//  Publishers.Scan.swift
+//
+//  Created by Eric Patey on 26.08.2019.
+//
+
+extension Publisher {
+
+    /// Transforms elements from the upstream publisher by providing the current
+    /// element to a closure along with the last value returned by the closure.
+    ///
+    /// Use `scan(_:_:)` to accumulate all previously-published values into a single
+    /// value, which you then combine with each newly-published value.
+    ///
+    /// The following example logs a running total of all values received
+    /// from the sequence publisher.
+    ///
+    ///     let range = (0...5)
+    ///     cancellable = range.publisher
+    ///         .scan(0) { return $0 + $1 }
+    ///         .sink { print ("\($0)", terminator: " ") }
+    ///      // Prints: "0 1 3 6 10 15 ".
+    ///
+    /// - Parameters:
+    ///   - initialResult: The previous result returned by the `nextPartialResult`
+    ///     closure.
+    ///   - nextPartialResult: A closure that takes as its arguments the previous value
+    ///     returned by the closure and the next element emitted from the upstream
+    ///     publisher.
+    /// - Returns: A publisher that transforms elements by applying a closure that
+    ///   receives its previous return value and the next element from the upstream
+    ///   publisher.
+    public func scan<Result>(
+        _ initialResult: Result,
+        _ nextPartialResult: @escaping (Result, Output) -> Result
+    ) -> Publishers.Scan<Self, Result> {
+        return .init(upstream: self,
+                     initialResult: initialResult,
+                     nextPartialResult: nextPartialResult)
+    }
+
+    /// Transforms elements from the upstream publisher by providing the current element
+    /// to an error-throwing closure along with the last value returned by the closure.
+    ///
+    /// Use `tryScan(_:_:)` to accumulate all previously-published values into a single
+    /// value, which you then combine with each newly-published value.
+    /// If your accumulator closure throws an error, the publisher terminates with
+    /// the error.
+    ///
+    /// In the example below, `tryScan(_:_:)` calls a division function on elements of
+    /// a collection publisher. The `Publishers.TryScan` publisher publishes each result
+    /// until the function encounters a `DivisionByZeroError`, which terminates
+    /// the publisher.
+    ///
+    ///     struct DivisionByZeroError: Error {}
+    ///
+    ///     /// A function that throws a DivisionByZeroError if `current` provided by the
+    ///     /// TryScan publisher is zero.
+    ///     func myThrowingFunction(_ lastValue: Int, _ currentValue: Int) throws -> Int {
+    ///         guard currentValue != 0 else { throw DivisionByZeroError() }
+    ///         return (lastValue + currentValue) / currentValue
+    ///      }
+    ///
+    ///     let numbers = [1,2,3,4,5,0,6,7,8,9]
+    ///     cancellable = numbers.publisher
+    ///         .tryScan(10) { try myThrowingFunction($0, $1) }
+    ///         .sink(
+    ///             receiveCompletion: { print ("\($0)") },
+    ///             receiveValue: { print ("\($0)", terminator: " ") }
+    ///          )
+    ///
+    ///     // Prints: "11 6 3 1 1 -1 failure(DivisionByZeroError())".
+    ///
+    /// If the closure throws an error, the publisher fails with the error.
+    ///
+    /// - Parameters:
+    ///   - initialResult: The previous result returned by the `nextPartialResult`
+    ///     closure.
+    ///   - nextPartialResult: An error-throwing closure that takes as its arguments the
+    ///     previous value returned by the closure and the next element emitted from the
+    ///     upstream publisher.
+    /// - Returns: A publisher that transforms elements by applying a closure that
+    ///   receives its previous return value and the next element from the upstream
+    ///   publisher.
+    public func tryScan<Result>(
+        _ initialResult: Result,
+        _ nextPartialResult: @escaping (Result, Output) throws -> Result
+    ) -> Publishers.TryScan<Self, Result> {
+        return .init(upstream: self,
+                     initialResult: initialResult,
+                     nextPartialResult: nextPartialResult)
+    }
+}
+
+extension Publishers {
+
+    public struct Scan<Upstream: Publisher, Output>: Publisher {
+
+        public typealias Failure = Upstream.Failure
+
+        public let upstream: Upstream
+
+        public let initialResult: Output
+
+        public let nextPartialResult: (Output, Upstream.Output) -> Output
+
+        public init(upstream: Upstream,
+                    initialResult: Output,
+                    nextPartialResult: @escaping (Output, Upstream.Output) -> Output) {
+            self.upstream = upstream
+            self.initialResult = initialResult
+            self.nextPartialResult = nextPartialResult
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Upstream.Failure == Downstream.Failure
+        {
+            upstream.subscribe(Inner(downstream: subscriber,
+                                     initialResult: initialResult,
+                                     nextPartialResult: nextPartialResult))
+        }
+    }
+
+    public struct TryScan<Upstream: Publisher, Output>: Publisher {
+
+        public typealias Failure = Error
+
+        public let upstream: Upstream
+
+        public let initialResult: Output
+
+        public let nextPartialResult: (Output, Upstream.Output) throws -> Output
+
+        public init(
+            upstream: Upstream,
+            initialResult: Output,
+            nextPartialResult: @escaping (Output, Upstream.Output) throws -> Output
+        ) {
+            self.upstream = upstream
+            self.initialResult = initialResult
+            self.nextPartialResult = nextPartialResult
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Output == Downstream.Input, Downstream.Failure == Error
+        {
+            upstream.subscribe(Inner(downstream: subscriber,
+                                     initialResult: initialResult,
+                                     nextPartialResult: nextPartialResult))
+        }
+    }
+}
+
+extension Publishers.Scan {
+
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Upstream.Failure == Downstream.Failure
+    {
+        // NOTE: this class has been audited for thread safety.
+        // Combine doesn't use any locking here.
+
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let nextPartialResult: (Downstream.Input, Input) -> Downstream.Input
+
+        private var result: Downstream.Input
+
+        fileprivate init(
+            downstream: Downstream,
+            initialResult: Downstream.Input,
+            nextPartialResult: @escaping (Downstream.Input, Input) -> Downstream.Input
+        )
+        {
+            self.downstream = downstream
+            self.result = initialResult
+            self.nextPartialResult = nextPartialResult
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            result = nextPartialResult(result, input)
+            return downstream.receive(result)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "Scan" }
+
+        var customMirror: Mirror {
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("result", result)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.TryScan {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Failure == Error
+    {
+        // NOTE: this class has been audited for thread safety.
+
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private let nextPartialResult:
+            (Downstream.Input, Input) throws -> Downstream.Input
+
+        private var result: Downstream.Input
+
+        private var status = SubscriptionStatus.awaitingSubscription
+
+        private let lock = UnfairLock.allocate()
+
+        private var finished = false
+
+        fileprivate init(
+            downstream: Downstream,
+            initialResult: Downstream.Input,
+            nextPartialResult:
+                @escaping (Downstream.Input, Input) throws -> Downstream.Input
+        ) {
+            self.downstream = downstream
+            self.nextPartialResult = nextPartialResult
+            self.result = initialResult
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func 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 {
+            do {
+                result = try nextPartialResult(result, input)
+                return downstream.receive(result)
+            } catch {
+                lock.lock()
+                guard case let .subscribed(subscription) = status else {
+                    lock.unlock()
+                    return .none
+                }
+                status = .terminal
+                lock.unlock()
+                subscription.cancel()
+                downstream.receive(completion: .failure(error))
+                return .none
+            }
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            // Combine doesn't use locking in this method!
+            guard case .subscribed = status else {
+                return
+            }
+            downstream.receive(completion: completion.eraseError())
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "TryScan" }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("downstream", downstream),
+                ("status", status),
+                ("result", result)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}