@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/Publishers/Publishers.HandleEvents.swift

@@ -0,0 +1,260 @@
+//
+//  Publishers.HandleEvents.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 03.12.2019.
+//
+
+extension Publisher {
+
+    /// Performs the specified closures when publisher events occur.
+    ///
+    /// Use `handleEvents` when you want to examine elements as they progress through
+    /// the stages of the publisher’s lifecycle.
+    ///
+    /// In the example below, a publisher of integers shows the effect of printing
+    /// debugging information at each stage of the element-processing lifecycle:
+    ///
+    ///     let integers = (0...2)
+    ///     cancellable = integers.publisher
+    ///         .handleEvents(receiveSubscription: { subs in
+    ///             print("Subscription: \(subs.combineIdentifier)")
+    ///         }, receiveOutput: { anInt in
+    ///             print("in output handler, received \(anInt)")
+    ///         }, receiveCompletion: { _ in
+    ///             print("in completion handler")
+    ///         }, receiveCancel: {
+    ///             print("received cancel")
+    ///         }, receiveRequest: { (demand) in
+    ///             print("received demand: \(demand.description)")
+    ///         })
+    ///         .sink { _ in return }
+    ///
+    ///     // Prints:
+    ///     //   received demand: unlimited
+    ///     //   Subscription: 0x7f81284734c0
+    ///     //   in output handler, received 0
+    ///     //   in output handler, received 1
+    ///     //   in output handler, received 2
+    ///     //   in completion handler
+    ///
+    /// - Parameters:
+    ///   - receiveSubscription: A closure that executes when the publisher receives
+    ///     the subscription from the upstream publisher. Defaults to `nil`.
+    ///   - receiveOutput: A closure that executes when the publisher receives a value
+    ///     from the upstream publisher. Defaults to `nil`.
+    ///   - receiveCompletion: A closure that executes when the publisher receives
+    ///     the completion from the upstream publisher. Defaults to `nil`.
+    ///   - receiveCancel: A closure that executes when the downstream receiver cancels
+    ///     publishing. Defaults to `nil`.
+    ///   - receiveRequest: A closure that executes when the publisher receives a request
+    ///     for more elements. Defaults to `nil`.
+    /// - Returns: A publisher that performs the specified closures when publisher events
+    ///   occur.
+    public func handleEvents(
+        receiveSubscription: ((Subscription) -> Void)? = nil,
+        receiveOutput: ((Output) -> Void)? = nil,
+        receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)? = nil,
+        receiveCancel: (() -> Void)? = nil,
+        receiveRequest: ((Subscribers.Demand) -> Void)? = nil
+    ) -> Publishers.HandleEvents<Self> {
+        return .init(upstream: self,
+                     receiveSubscription: receiveSubscription,
+                     receiveOutput: receiveOutput,
+                     receiveCompletion: receiveCompletion,
+                     receiveCancel: receiveCancel,
+                     receiveRequest: receiveRequest)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that performs the specified closures when publisher events occur.
+    public struct HandleEvents<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
+
+        /// A closure that executes when the publisher receives the subscription from
+        /// the upstream publisher.
+        public var receiveSubscription: ((Subscription) -> Void)?
+
+        ///  A closure that executes when the publisher receives a value from the upstream
+        ///  publisher.
+        public var receiveOutput: ((Upstream.Output) -> Void)?
+
+        /// A closure that executes when the publisher receives the completion from
+        /// the upstream publisher.
+        public var receiveCompletion:
+            ((Subscribers.Completion<Upstream.Failure>) -> Void)?
+
+        ///  A closure that executes when the downstream receiver cancels publishing.
+        public var receiveCancel: (() -> Void)?
+
+        /// A closure that executes when the publisher receives a request for more
+        /// elements.
+        public var receiveRequest: ((Subscribers.Demand) -> Void)?
+
+        public init(
+            upstream: Upstream,
+            receiveSubscription: ((Subscription) -> Void)? = nil,
+            receiveOutput: ((Output) -> Void)? = nil,
+            receiveCompletion: ((Subscribers.Completion<Failure>) -> Void)? = nil,
+            receiveCancel: (() -> Void)? = nil,
+            receiveRequest: ((Subscribers.Demand) -> Void)?
+        ) {
+            self.upstream = upstream
+            self.receiveSubscription = receiveSubscription
+            self.receiveOutput = receiveOutput
+            self.receiveCompletion = receiveCompletion
+            self.receiveCancel = receiveCancel
+            self.receiveRequest = receiveRequest
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            let inner = Inner(self, downstream: subscriber)
+            upstream.subscribe(inner)
+        }
+    }
+}
+
+extension Publishers.HandleEvents {
+    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 var status = SubscriptionStatus.awaitingSubscription
+        private let lock = UnfairLock.allocate()
+        fileprivate var receiveSubscription: ((Subscription) -> Void)?
+        fileprivate var receiveOutput: ((Upstream.Output) -> Void)?
+        fileprivate var receiveCompletion:
+            ((Subscribers.Completion<Upstream.Failure>) -> Void)?
+        fileprivate var receiveCancel: (() -> Void)?
+        fileprivate var receiveRequest: ((Subscribers.Demand) -> Void)?
+        private let downstream: Downstream
+
+        init(_ events: Publishers.HandleEvents<Upstream>, downstream: Downstream) {
+            self.receiveSubscription = events.receiveSubscription
+            self.receiveOutput = events.receiveOutput
+            self.receiveCompletion = events.receiveCompletion
+            self.receiveCancel = events.receiveCancel
+            self.receiveRequest = events.receiveRequest
+            self.downstream = downstream
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            if let receiveSubscription = self.receiveSubscription {
+                lock.unlock()
+                receiveSubscription(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 {
+            lock.lock()
+            if let receiveOutput = self.receiveOutput {
+                lock.unlock()
+                receiveOutput(input)
+            } else {
+                lock.unlock()
+            }
+            let newDemand = downstream.receive(input)
+            if newDemand == .none {
+                return newDemand
+            }
+            lock.lock()
+            if let receiveRequest = self.receiveRequest {
+                lock.unlock()
+                receiveRequest(newDemand)
+            } else {
+                lock.unlock()
+            }
+            return newDemand
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            if let receiveCompletion = self.receiveCompletion {
+                lock.unlock()
+                receiveCompletion(completion)
+                lock.lock()
+            }
+            lockedTerminate()
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            if let receiveRequest = self.receiveRequest {
+                lock.unlock()
+                receiveRequest(demand)
+                lock.lock()
+            }
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            if let receiveCancel = self.receiveCancel {
+                lock.unlock()
+                receiveCancel()
+                lock.lock()
+            }
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            lockedTerminate()
+            lock.unlock()
+            subscription.cancel()
+        }
+
+        var description: String { return "HandleEvents" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+
+        private func lockedTerminate() {
+            receiveSubscription = nil
+            receiveOutput       = nil
+            receiveCompletion   = nil
+            receiveCancel       = nil
+            receiveRequest      = nil
+            status = .terminal
+        }
+    }
+}

package/Sources/Combine/Publishers/Publishers.IgnoreOutput.swift

@@ -0,0 +1,109 @@
+//
+//  Publishers.IgnoreOutput.swift
+//
+//  Created by Eric Patey on 16.08.2019.
+//
+
+extension Publisher {
+
+    /// Ingores all upstream elements, but passes along a completion state (finished or
+    /// failed).
+    ///
+    /// Use the `ignoreOutput(`` operator to determine if a publisher is able to complete
+    /// successfully or would fail.
+    ///
+    /// In the example below, the array publisher (`numbers`) delivers the first five of
+    /// its elements successfully, as indicated by the `ignoreOutput()` operator.
+    /// The operator consumes, but doesn’t republish the elements downstream. However,
+    /// the sixth element, `0`, causes the error throwing closure to catch
+    /// a `NoZeroValuesAllowedError` that terminates the stream.
+    ///
+    ///     struct NoZeroValuesAllowedError: Error {}
+    ///     let numbers = [1, 2, 3, 4, 5, 0, 6, 7, 8, 9]
+    ///     cancellable = numbers.publisher
+    ///         .tryFilter({ anInt in
+    ///             guard anInt != 0 else { throw NoZeroValuesAllowedError() }
+    ///             return anInt < 20
+    ///         })
+    ///         .ignoreOutput()
+    ///         .sink(receiveCompletion: {print("completion: \($0)")},
+    ///               receiveValue: {print("value \($0)")})
+    ///
+    ///     // Prints: "completion: failure(NoZeroValuesAllowedError())"
+    ///
+    /// The output type of this publisher is `Never`.
+    ///
+    /// - Returns: A publisher that ignores all upstream elements.
+    public func ignoreOutput() -> Publishers.IgnoreOutput<Self> {
+        return .init(upstream: self)
+    }
+}
+
+extension Publishers {
+    /// A publisher that ignores all upstream elements, but passes along a completion
+    /// state (finish or failed).
+    public struct IgnoreOutput<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Never
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        public init(upstream: Upstream) {
+            self.upstream = upstream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Upstream.Failure, Downstream.Input == Never
+        {
+            upstream.subscribe(Inner<Downstream>(downstream: subscriber))
+        }
+    }
+}
+
+extension Publishers.IgnoreOutput {
+    private struct Inner<Downstream: Subscriber>
+        : Subscriber,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Never, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        let combineIdentifier = CombineIdentifier()
+
+        fileprivate init(downstream: Downstream) {
+            self.downstream = downstream
+        }
+
+        func receive(subscription: Subscription) {
+            downstream.receive(subscription: subscription)
+            subscription.request(.unlimited)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            return .none
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            downstream.receive(completion: completion)
+        }
+
+        var description: String { return "IgnoreOutput" }
+
+        var customMirror: Mirror {
+            return Mirror(self, children: EmptyCollection())
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Publishers.IgnoreOutput: Equatable where Upstream: Equatable {}

package/Sources/Combine/Publishers/Publishers.Last.swift

@@ -0,0 +1,252 @@
+//
+//  Publishers.Last.swift
+//  
+//
+//  Created by Joseph Spadafora on 7/9/19.
+//
+
+extension Publisher {
+
+    /// Publishes the last element of a stream, after the stream finishes.
+    ///
+    /// Use `last()` when you need to emit only the last element from an upstream
+    /// publisher.
+    ///
+    /// In the example below, the range publisher only emits the last element from
+    /// the sequence publisher, `10`, then finishes normally.
+    ///
+    ///     let numbers = (-10...10)
+    ///     cancellable = numbers.publisher
+    ///         .last()
+    ///         .sink { print("\($0)") }
+    ///
+    ///     // Prints: "10"
+    ///
+    /// - Returns: A publisher that only publishes the last element of a stream.
+    public func last() -> Publishers.Last<Self> {
+        return .init(upstream: self)
+    }
+
+    /// Publishes the last element of a stream that satisfies a predicate closure,
+    /// after upstream finishes.
+    ///
+    /// Use `last(where:)` when you need to republish only the last element of a stream
+    /// that satisfies a closure you specify.
+    ///
+    /// In the example below, a range publisher emits the last element that satisfies
+    /// the closure’s criteria, then finishes normally:
+    ///
+    ///     let numbers = (-10...10)
+    ///     cancellable = numbers.publisher
+    ///         .last { $0 < 6 }
+    ///         .sink { print("\($0)") }
+    ///
+    ///     // Prints: "5"
+    ///
+    /// - Parameter predicate: A closure that takes an element as its parameter and
+    ///   returns a Boolean value that indicates whether to publish the element.
+    /// - Returns: A publisher that only publishes the last element satisfying the given
+    ///   predicate.
+    public func last(
+        where predicate: @escaping (Output) -> Bool
+    ) -> Publishers.LastWhere<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+
+    /// Publishes the last element of a stream that satisfies an error-throwing predicate
+    /// closure, after the stream finishes.
+    ///
+    /// Use `tryLast(where:)` when you need to republish the last element that satisfies
+    /// an error-throwing closure you specify. If the predicate closure throws an error,
+    /// the publisher fails.
+    ///
+    /// In the example below, a publisher emits the last element that satisfies
+    /// the error-throwing closure, then finishes normally:
+    ///
+    ///     struct RangeError: Error {}
+    ///
+    ///     let numbers = [-62, 1, 6, 10, 9, 22, 41, -1, 5]
+    ///     cancellable = numbers.publisher
+    ///         .tryLast {
+    ///             guard 0 != 0  else {throw RangeError()}
+    ///             return true
+    ///         }
+    ///         .sink(
+    ///             receiveCompletion: { print ("completion: \($0)", terminator: " ") },
+    ///             receiveValue: { print ("\($0)", terminator: " ") }
+    ///         )
+    ///     // Prints: "5 completion: finished"
+    ///     // If instead the numbers array had contained a `0`, the `tryLast` operator
+    ///     // would terminate publishing with a RangeError."
+    ///
+    /// - Parameter predicate: A closure that takes an element as its parameter and
+    ///   returns a Boolean value that indicates whether to publish the element.
+    /// - Returns: A publisher that only publishes the last element satisfying the given
+    ///   predicate.
+    public func tryLast(
+        where predicate: @escaping (Output) throws -> Bool
+    ) -> Publishers.TryLastWhere<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that only publishes the last element of a stream,
+    /// after the stream finishes.
+    public struct Last<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
+
+        public init(upstream: Upstream) {
+            self.upstream = upstream
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Failure == Downstream.Failure, Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(downstream: subscriber))
+        }
+    }
+
+    /// A publisher that only publishes the last element of a stream that satisfies
+    /// a predicate closure, once the stream finishes.
+    public struct LastWhere<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 closure that determines whether to publish an element.
+        public let predicate: (Upstream.Output) -> Bool
+
+        public init(upstream: Upstream, predicate: @escaping (Output) -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Failure == Downstream.Failure, Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(downstream: subscriber, predicate: predicate))
+        }
+    }
+
+    /// A publisher that only publishes the last element of a stream that satisfies
+    /// an error-throwing predicate closure, once the stream finishes.
+    public struct TryLastWhere<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Error
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// The error-throwing closure that determines whether to publish an element.
+        public let predicate: (Upstream.Output) throws -> Bool
+
+        public init(upstream: Upstream, predicate: @escaping (Output) throws -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Error, Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(downstream: subscriber, predicate: predicate))
+        }
+    }
+}
+
+extension Publishers.Last: Equatable where Upstream: Equatable {}
+
+extension Publishers.Last {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Upstream.Output,
+                         Upstream.Failure,
+                         Void>
+        where Upstream.Output == Downstream.Input, Upstream.Failure == Downstream.Failure
+    {
+        fileprivate init(downstream: Downstream) {
+            super.init(downstream: downstream, initial: nil, reduce: ())
+        }
+
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            result = newValue
+            return .continue
+        }
+
+        override var description: String { return "Last" }
+    }
+}
+
+extension Publishers.LastWhere {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Upstream.Output,
+                         Upstream.Failure,
+                         (Upstream.Output) -> Bool>
+        where Upstream.Output == Downstream.Input, Upstream.Failure == Downstream.Failure
+    {
+        fileprivate init(downstream: Downstream,
+                         predicate: @escaping (Upstream.Output) -> Bool) {
+            super.init(downstream: downstream, initial: nil, reduce: predicate)
+        }
+
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            if reduce(newValue) {
+                result = newValue
+            }
+            return .continue
+        }
+
+        override var description: String { return "LastWhere" }
+    }
+}
+
+extension Publishers.TryLastWhere {
+    private final class Inner<Downstream: Subscriber>
+        : ReduceProducer<Downstream,
+                         Upstream.Output,
+                         Upstream.Output,
+                         Upstream.Failure,
+                         (Upstream.Output) throws -> Bool>
+        where Upstream.Output == Downstream.Input, Downstream.Failure == Error
+    {
+        fileprivate init(downstream: Downstream,
+                         predicate: @escaping (Upstream.Output) throws -> Bool) {
+            super.init(downstream: downstream, initial: nil, reduce: predicate)
+        }
+
+        override func receive(
+            newValue: Upstream.Output
+        ) -> PartialCompletion<Void, Downstream.Failure> {
+            do {
+                if try reduce(newValue) {
+                    result = newValue
+                }
+                return .continue
+            } catch {
+                return .failure(error)
+            }
+        }
+
+        override var description: String { return "TryLastWhere" }
+    }
+}