@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/Combine/Publishers/Publishers.Output.swift

@@ -0,0 +1,241 @@
+//
+//  Publishers.Output.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 24.10.2019.
+//
+
+extension Publisher {
+
+    /// Republishes elements up to the specified maximum count.
+    ///
+    /// Use `prefix(_:)` to limit the number of elements republished to the downstream
+    /// subscriber.
+    ///
+    /// In the example below, the `prefix(_:)` operator limits its output to the first
+    /// two elements before finishing normally:
+    ///
+    ///     let numbers = (0...10)
+    ///     cancellable = numbers.publisher
+    ///         .prefix(2)
+    ///         .sink { print("\($0)", terminator: " ") }
+    ///
+    ///     // Prints: "0 1"
+    ///
+    /// - Parameter maxLength: The maximum number of elements to republish.
+    /// - Returns: A publisher that publishes up to the specified number of elements
+    ///   before completing.
+    public func prefix(_ maxLength: Int) -> Publishers.Output<Self> {
+        return output(in: ..<maxLength)
+    }
+}
+
+extension Publisher {
+
+    /// Publishes a specific element, indicated by its index in the sequence of published
+    /// elements.
+    ///
+    /// Use `output(at:)` when you need to republish a specific element specified by
+    /// its position in the stream. If the publisher completes normally or with an error
+    /// before publishing the specified element, then the publisher doesn’t produce any
+    /// elements.
+    ///
+    /// In the example below, the array publisher emits the fifth element in the sequence
+    /// of published elements:
+    ///
+    ///     let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    ///     numbers.publisher
+    ///         .output(at: 5)
+    ///         .sink { print("\($0)") }
+    ///
+    ///     // Prints: "6"
+    ///
+    /// - Parameter index: The index that indicates the element to publish.
+    /// - Returns: A publisher that publishes a specific indexed element.
+    public func output(at index: Int) -> Publishers.Output<Self> {
+        return output(in: index...index)
+    }
+
+    /// Publishes elements specified by their range in the sequence of published elements.
+    ///
+    /// Use `output(in:)` to republish a range indices you specify in the published
+    /// stream. After publishing all elements, the publisher finishes normally.
+    /// If the publisher completes normally or with an error before producing all
+    /// the elements in the range, it doesn’t publish the remaining elements.
+    ///
+    /// In the example below, an array publisher emits the subset of elements at
+    /// the indices in the specified range:
+    ///
+    ///     let numbers = [1, 1, 2, 2, 2, 3, 4, 5, 6]
+    ///     numbers.publisher
+    ///         .output(in: (3...5))
+    ///         .sink { print("\($0)", terminator: " ") }
+    ///
+    ///     // Prints: "2 2 3"
+    ///
+    /// - Parameter range: A range that indicates which elements to publish.
+    /// - Returns: A publisher that publishes elements specified by a range.
+    public func output<Range: RangeExpression>(in range: Range) -> Publishers.Output<Self>
+        where Range.Bound == Int
+    {
+        return .init(upstream: self, range: range.relative(to: 0 ..< .max))
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that publishes elements specified by a range in the sequence of
+    /// published elements.
+    public struct Output<Upstream: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher that this publisher receives elements from.
+        public let upstream: Upstream
+
+        /// The range of elements to publish.
+        public let range: CountableRange<Int>
+
+        /// Creates a publisher that publishes elements specified by a range.
+        ///
+        /// - Parameters:
+        ///   - upstream: The publisher that this publisher receives elements from.
+        ///   - range: The range of elements to publish.
+        public init(upstream: Upstream, range: CountableRange<Int>) {
+            precondition(range.lowerBound >= 0, "lowerBound must not be negative")
+            precondition(range.upperBound >= 0, "upperBound must not be negative")
+            self.upstream = upstream
+            self.range = range
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(downstream: subscriber, range: range))
+        }
+    }
+}
+
+extension Publishers.Output: Equatable where Upstream: Equatable {}
+
+extension Publishers.Output {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        // NOTE: This class has been audited for thread safety
+
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private let downstream: Downstream
+
+        private var status = SubscriptionStatus.awaitingSubscription
+
+        private var remainingUntilStart: Int
+
+        private var remainingCount: Int
+
+        private let lock = UnfairLock.allocate()
+
+        fileprivate init(downstream: Downstream, range: CountableRange<Int>) {
+            self.downstream = downstream
+            self.remainingUntilStart = range.lowerBound
+            self.remainingCount = range.count
+        }
+
+        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: Upstream.Output) -> Subscribers.Demand {
+            if remainingUntilStart > 0 {
+                remainingUntilStart -= 1
+                return .max(1)
+            }
+
+            let newDemand: Subscribers.Demand
+            if remainingCount > 0 {
+                remainingCount -= 1
+                newDemand = downstream.receive(input)
+            } else {
+                newDemand = .none
+                cancelUpstreamAndFinish()
+            }
+            return newDemand
+        }
+
+        func receive(completion: Subscribers.Completion<Upstream.Failure>) {
+            lock.lock()
+            guard case .subscribed = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            lock.unlock()
+            downstream.receive(completion: completion)
+        }
+
+        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 "Output" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+
+        // MARK: - Private
+
+        private func cancelUpstreamAndFinish() {
+            assert(remainingCount == 0)
+            lock.lock()
+            guard case let .subscribed(subscription) = status else {
+                lock.unlock()
+                return
+            }
+            status = .terminal
+            lock.unlock()
+            subscription.cancel()
+            downstream.receive(completion: .finished)
+        }
+    }
+}

package/Sources/Combine/Publishers/Publishers.PrefixUntilOutput.swift

@@ -0,0 +1,197 @@
+//
+//  Publishers.PrefixUntilOutput.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 08.11.2020.
+//
+
+extension Publisher {
+
+    /// Republishes elements until another publisher emits an element.
+    ///
+    /// After the second publisher publishes an element, the publisher returned by this
+    /// method finishes.
+    ///
+    /// - Parameter publisher: A second publisher.
+    /// - Returns: A publisher that republishes elements until the second publisher
+    ///   publishes an element.
+    public func prefix<Other: Publisher>(
+        untilOutputFrom publisher: Other
+    ) -> Publishers.PrefixUntilOutput<Self, Other> {
+        return .init(upstream: self, other: publisher)
+    }
+}
+
+extension Publishers {
+    public struct PrefixUntilOutput<Upstream: Publisher, Other: Publisher>: Publisher {
+
+        public typealias Output = Upstream.Output
+
+        public typealias Failure = Upstream.Failure
+
+        /// The publisher from which this publisher receives elements.
+        public let upstream: Upstream
+
+        /// Another publisher, whose first output causes this publisher to finish.
+        public let other: Other
+
+        public init(upstream: Upstream, other: Other) {
+            self.upstream = upstream
+            self.other = other
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Downstream.Failure == Failure, Downstream.Input == Output
+        {
+            upstream.subscribe(Inner(downstream: subscriber, trigger: other))
+        }
+    }
+}
+
+extension Publishers.PrefixUntilOutput {
+    private final class Inner<Downstream: Subscriber>
+        : Subscriber,
+          Subscription
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        private struct Termination: Subscriber {
+
+            let inner: Inner
+
+            var combineIdentifier: CombineIdentifier {
+                return inner.combineIdentifier
+            }
+
+            func receive(subscription: Subscription) {
+                inner.terminationReceive(subscription: subscription)
+            }
+
+            func receive(_ input: Other.Output) -> Subscribers.Demand {
+                return inner.terminationReceive(input)
+            }
+
+            func receive(completion: Subscribers.Completion<Other.Failure>) {
+                inner.terminationReceive(completion: completion)
+            }
+        }
+
+        private var termination: Termination?
+        private var prefixState = SubscriptionStatus.awaitingSubscription
+        private var terminationState = SubscriptionStatus.awaitingSubscription
+        private var triggered = false
+        private let lock = UnfairLock.allocate()
+        private let downstream: Downstream
+
+        init(downstream: Downstream, trigger: Other) {
+            self.downstream = downstream
+            let termination = Termination(inner: self)
+            self.termination = termination
+            trigger.subscribe(termination)
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        func receive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = prefixState else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            prefixState = triggered ? .terminal : .subscribed(subscription)
+            lock.unlock()
+            downstream.receive(subscription: self)
+        }
+
+        func receive(_ input: Input) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = prefixState else {
+                lock.unlock()
+                return .none
+            }
+            lock.unlock()
+            return downstream.receive(input)
+        }
+
+        func receive(completion: Subscribers.Completion<Failure>) {
+            lock.lock()
+            let prefixState = self.prefixState
+            let terminationSubscription = terminationState.subscription
+            self.prefixState = .terminal
+            terminationState = .terminal
+            termination = nil
+            lock.unlock()
+            terminationSubscription?.cancel()
+            if case .subscribed = prefixState {
+                downstream.receive(completion: completion)
+            }
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard case let .subscribed(subscription) = prefixState else {
+                lock.unlock()
+                return
+            }
+            lock.unlock()
+            subscription.request(demand)
+        }
+
+        func cancel() {
+            lock.lock()
+            let prefixSubscription = prefixState.subscription
+            let terminationSubscription = terminationState.subscription
+            prefixState = .terminal
+            terminationState = .terminal
+            lock.unlock()
+            prefixSubscription?.cancel()
+            terminationSubscription?.cancel()
+        }
+
+        // MARK: - Private
+
+        private func terminationReceive(subscription: Subscription) {
+            lock.lock()
+            guard case .awaitingSubscription = terminationState else {
+                lock.unlock()
+                subscription.cancel()
+                return
+            }
+            terminationState = .subscribed(subscription)
+            lock.unlock()
+            subscription.request(.max(1))
+        }
+
+        private func terminationReceive(_ input: Other.Output) -> Subscribers.Demand {
+            lock.lock()
+            guard case .subscribed = terminationState else {
+                lock.unlock()
+                return .none
+            }
+            let prefixSubscription = prefixState.subscription
+            prefixState = .terminal
+            terminationState = .terminal
+            termination = nil
+            triggered = true
+            lock.unlock()
+            prefixSubscription?.cancel()
+            downstream.receive(completion: .finished)
+            return .none
+        }
+
+        private func terminationReceive(
+            completion: Subscribers.Completion<Other.Failure>
+        ) {
+            lock.lock()
+            terminationState = .terminal
+            termination = nil
+            lock.unlock()
+        }
+    }
+}

package/Sources/Combine/Publishers/Publishers.PrefixWhile.swift

@@ -0,0 +1,176 @@
+//
+//  Publishers.PrefixWhile.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 24.10.2019.
+//
+
+extension Publisher {
+
+    /// Republishes elements while a predicate closure indicates publishing should
+    /// continue.
+    ///
+    /// Use `prefix(while:)` to emit values while elements from the upstream publishe
+    /// meet a condition you specify. The publisher finishes when the closure returns
+    /// `false`.
+    ///
+    /// In the example below, the `prefix(while:)` operator emits values while the element
+    /// it receives is less than five:
+    ///
+    ///     let numbers = (0...10)
+    ///     numbers.publisher
+    ///         .prefix { $0 < 5 }
+    ///         .sink { print("\($0)", terminator: " ") }
+    ///
+    ///     // Prints: "0 1 2 3 4"
+    ///
+    /// - Parameter predicate: A closure that takes an element as its parameter and
+    ///   returns a Boolean value that indicates whether publishing should continue.
+    /// - Returns: A publisher that passes through elements until the predicate indicates
+    ///   publishing should finish.
+    public func prefix(
+        while predicate: @escaping (Output) -> Bool
+    ) -> Publishers.PrefixWhile<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+
+    /// Republishes elements while an error-throwing predicate closure indicates
+    /// publishing should continue.
+    ///
+    /// Use `tryPrefix(while:)` to emit values from the upstream publisher that meet
+    /// a condition you specify in an error-throwing closure.
+    /// The publisher finishes when the closure returns `false`. If the closure throws
+    /// an error, the publisher fails with that error.
+    ///
+    ///     struct OutOfRangeError: Error {}
+    ///
+    ///     let numbers = (0...10).reversed()
+    ///     cancellable = numbers.publisher
+    ///         .tryPrefix {
+    ///             guard $0 != 0 else { throw OutOfRangeError() }
+    ///             return $0 <= numbers.max()!
+    ///         }
+    ///         .sink(
+    ///             receiveCompletion: { print ("completion: \($0)", terminator: " ") },
+    ///             receiveValue: { print ("\($0)", terminator: " ") }
+    ///         )
+    ///
+    ///     // Prints: "10 9 8 7 6 5 4 3 2 1 completion: failure(OutOfRangeError()) "
+    ///
+    /// - Parameter predicate: A closure that takes an element as its parameter and
+    ///   returns a Boolean value indicating whether publishing should continue.
+    /// - Returns: A publisher that passes through elements until the predicate throws or
+    ///   indicates publishing should finish.
+    public func tryPrefix(
+        while predicate: @escaping (Output) throws -> Bool
+    ) -> Publishers.TryPrefixWhile<Self> {
+        return .init(upstream: self, predicate: predicate)
+    }
+}
+
+extension Publishers {
+
+    /// A publisher that republishes elements while a predicate closure indicates
+    /// publishing should continue.
+    public struct PrefixWhile<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 whether publishing should continue.
+        public let predicate: (Upstream.Output) -> Bool
+
+        public init(upstream: Upstream, predicate: @escaping (Upstream.Output) -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Failure == Downstream.Failure,
+                  Upstream.Output == Downstream.Input
+        {
+            upstream.subscribe(Inner(downstream: subscriber, filter: predicate))
+        }
+    }
+
+    /// A publisher that republishes elements while an error-throwing predicate closure
+    /// indicates publishing should continue.
+    public struct TryPrefixWhile<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 publishing should continue.
+        public let predicate: (Upstream.Output) throws -> Bool
+
+        public init(upstream: Upstream,
+                    predicate: @escaping (Upstream.Output) throws -> Bool) {
+            self.upstream = upstream
+            self.predicate = predicate
+        }
+
+        public func receive<Downstream: Subscriber>(subscriber: Downstream)
+            where Upstream.Output == Downstream.Input, Downstream.Failure == Error
+        {
+            upstream.subscribe(Inner(downstream: subscriber, filter: predicate))
+        }
+    }
+}
+
+extension Publishers.PrefixWhile {
+    private final class Inner<Downstream: Subscriber>
+        : FilterProducer<Downstream,
+                         Upstream.Output,
+                         Upstream.Output,
+                         Upstream.Failure,
+                         (Upstream.Output) -> Bool>
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Upstream.Failure
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        override func receive(
+            newValue: Input
+        ) -> PartialCompletion<Upstream.Output?, Downstream.Failure> {
+            return filter(newValue) ? .continue(newValue) : .finished
+        }
+
+        override var description: String { return "PrefixWhile" }
+    }
+}
+
+extension Publishers.TryPrefixWhile {
+    private final class Inner<Downstream: Subscriber>
+        : FilterProducer<Downstream,
+                         Upstream.Output,
+                         Upstream.Output,
+                         Upstream.Failure,
+                         (Upstream.Output) throws -> Bool>
+        where Downstream.Input == Upstream.Output, Downstream.Failure == Error
+    {
+        typealias Input = Upstream.Output
+
+        typealias Failure = Upstream.Failure
+
+        override func receive(
+            newValue: Input
+        ) -> PartialCompletion<Upstream.Output?, Downstream.Failure> {
+            do {
+                return try filter(newValue) ? .continue(newValue) : .finished
+            } catch {
+                return .failure(error)
+            }
+        }
+
+        override var description: String { return "TryPrefixWhile" }
+    }
+}