@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Combine/Publishers/Publishers.swift

@@ -0,0 +1,13 @@
+//
+//  Publishers.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 14.06.2019.
+//
+
+/// A namespace for types that serve as publishers.
+///
+/// The various operators defined as extensions on `Publisher` implement their
+/// functionality as classes or structures that extend this enumeration.
+/// For example, the `contains(_:)` operator returns a `Publishers.Contains` instance.
+public enum Publishers {}

package/Sources/Combine/Publishers/Record.swift

@@ -0,0 +1,237 @@
+//
+//  Record.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 12.11.2019.
+//
+
+/// A publisher that allows for recording a series of inputs and a completion for later
+/// playback to each subscriber.
+public struct Record<Output, Failure: Error>: Publisher {
+
+    /// The recorded output and completion.
+    public let recording: Recording
+
+    /// Creates a publisher to interactively record a series of outputs and a completion.
+    ///
+    /// - Parameter record: A recording instance that can be retrieved after completion
+    ///   to create new record publishers to replay the recording.
+    public init(record: (inout Recording) -> Void) {
+        var recording = Recording()
+        record(&recording)
+        self.init(recording: recording)
+    }
+
+    /// Creates a record publisher from an existing recording.
+    ///
+    /// - Parameter recording: A previously-recorded recording of published elements
+    ///   and a completion.
+    public init(recording: Recording) {
+        self.recording = recording
+    }
+
+    /// Creates a record publisher to publish the provided elements, followed by
+    /// the provided completion value.
+    ///
+    /// - Parameters:
+    ///   - output: An array of output elements to publish.
+    ///   - completion: The completion value with which to end publishing.
+    public init(output: [Output], completion: Subscribers.Completion<Failure>) {
+        self.init(recording: Recording(output: output, completion: completion))
+    }
+
+    public func receive<Downstream: Subscriber>(subscriber: Downstream)
+        where Output == Downstream.Input, Failure == Downstream.Failure
+    {
+        if recording.output.isEmpty {
+            subscriber.receive(subscription: Subscriptions.empty)
+            subscriber.receive(completion: recording.completion)
+        } else {
+            let inner = Inner(downstream: subscriber,
+                              sequence: recording.output,
+                              completion: recording.completion)
+            subscriber.receive(subscription: inner)
+        }
+    }
+
+    /// A recorded sequence of outputs, followed by a completion value.
+    public struct Recording {
+
+        public typealias Input = Output
+
+        private enum State {
+            case input
+            case complete
+        }
+
+        private var state: State
+
+        /// The output which will be sent to a `Subscriber`.
+        public private(set) var output: [Output]
+
+        /// The completion which will be sent to a `Subscriber`.
+        public private(set) var completion: Subscribers.Completion<Failure>
+
+        /// Set up a recording in a state ready to receive output.
+        public init() {
+            state = .input
+            output = []
+            completion = .finished
+        }
+
+        /// Set up a complete recording with the specified output and completion.
+        public init(output: [Output],
+                    completion: Subscribers.Completion<Failure> = .finished) {
+            self.state = .complete
+            self.output = output
+            self.completion = completion
+        }
+
+        /// Add an output to the recording.
+        ///
+        /// A `fatalError` will be raised if output is added after adding completion.
+        public mutating func receive(_ input: Input) {
+            precondition(state == .input,
+                         "Receiving values after completion is not allowed")
+            output.append(input)
+        }
+
+        /// Add a completion to the recording.
+        ///
+        /// A `fatalError` will be raised if more than one completion is added.
+        public mutating func receive(completion: Subscribers.Completion<Failure>) {
+            precondition(state == .input,
+                         "Receiving completion more than once is not allowed")
+            self.completion = completion
+            self.state = .complete
+        }
+    }
+}
+
+extension Record: Codable where Output: Codable, Failure: Codable {}
+
+extension Record.Recording: Codable where Output: Codable, Failure: Codable {
+
+    private enum CodingKeys: String, CodingKey {
+        case output = "output"
+        case completion = "completion"
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        let output = try container.decode([Output].self, forKey: .output)
+        let completion = try container.decode(Subscribers.Completion<Failure>.self,
+                                              forKey: .completion)
+        self.init(output: output, completion: completion)
+    }
+
+    public func encode(into encoder: Encoder) throws {
+        try encode(to: encoder)
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(output, forKey: .output)
+        try container.encode(completion, forKey: .completion)
+    }
+}
+
+extension Record {
+
+    // This class is almost the same as Publishers.Sequence.Inner
+    // despite some small details.
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+    where Downstream.Input == Output, Downstream.Failure == Failure
+    {
+        // NOTE: This class has been audited for thread-safety
+
+        private var sequence: [Output]?
+        private let completion: Subscribers.Completion<Failure>
+        private var downstream: Downstream?
+        private var iterator: IndexingIterator<[Output]>
+        private var next: Output?
+        private var pendingDemand = Subscribers.Demand.none
+        private var recursion = false
+        private var lock = UnfairLock.allocate()
+
+        fileprivate init(downstream: Downstream,
+                         sequence: [Output],
+                         completion: Subscribers.Completion<Failure>) {
+            self.sequence = sequence
+            self.completion = completion
+            self.downstream = downstream
+            self.iterator = sequence.makeIterator()
+            next = iterator.next()
+        }
+
+        deinit {
+            lock.deallocate()
+        }
+
+        var description: String {
+            lock.lock()
+            defer { lock.unlock() }
+            return sequence.map { $0.description } ?? "Cancelled Events"
+        }
+
+        var customMirror: Mirror {
+            lock.lock()
+            defer { lock.unlock() }
+            let children: [Mirror.Child] = [
+                ("sequence", sequence ?? [Output]()),
+                ("completion", completion)
+            ]
+            return Mirror(self, children: children)
+        }
+
+        var playgroundDescription: Any { return description }
+
+        func request(_ demand: Subscribers.Demand) {
+            lock.lock()
+            guard downstream != nil else {
+                lock.unlock()
+                return
+            }
+            pendingDemand += demand
+            if recursion {
+                lock.unlock()
+                return
+            }
+
+            while let downstream = self.downstream, pendingDemand > 0 {
+                if let current = self.next {
+                    pendingDemand -= 1
+                    let next = iterator.next()
+                    recursion = true
+                    lock.unlock()
+                    let additionalDemand = downstream.receive(current)
+                    lock.lock()
+                    recursion = false
+                    pendingDemand += additionalDemand
+                    self.next = next
+                }
+
+                if next == nil {
+                    self.downstream = nil
+                    self.sequence = nil
+                    lock.unlock()
+                    downstream.receive(completion: completion)
+                    return
+                }
+            }
+
+            lock.unlock()
+        }
+
+        func cancel() {
+            lock.lock()
+            downstream = nil
+            sequence = nil
+            lock.unlock()
+        }
+    }
+}

package/Sources/Combine/Publishers/Result.Publisher.swift

@@ -0,0 +1,337 @@
+//
+//  Result.Publisher.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 17.06.2019.
+//
+
+extension Result {
+
+    /// A namespace for disambiguation when both OpenCombine and Combine are imported.
+    ///
+    /// Combine extends `Result` with a nested type `Publisher`.
+    /// If you import both OpenCombine and Combine (either explicitly or implicitly,
+    /// e. g. when importing Foundation), you will not be able
+    /// to write `Result<Int, Error>.Publisher`,
+    /// because Swift is unable to understand which `Publisher` you're referring to.
+    ///
+    /// So you have to write `Result<Int, Error>.OCombine.Publisher`.
+    ///
+    /// This bug is tracked [here](https://bugs.swift.org/browse/SR-11183).
+    ///
+    /// You can omit this whenever Combine is not available (e. g. on Linux).
+    public struct OCombine {
+
+        fileprivate let result: Result
+
+        fileprivate init(_ result: Result) {
+            self.result = result
+        }
+
+        public var publisher: Publisher {
+            return Publisher(result)
+        }
+
+        /// A publisher that publishes an output to each subscriber exactly once then
+        /// finishes, or fails immediately without producing any elements.
+        ///
+        /// If `result` is `.success`, then `Once` waits until it receives a request for
+        /// at least 1 value before sending the output. If `result` is `.failure`,
+        /// then `Once` sends the failure immediately upon subscription.
+        ///
+        /// In contrast with `Just`, a `Once` publisher can terminate with an error
+        /// instead of sending a value. In contrast with `Optional`, a `Once` publisher
+        /// always sends one value (unless it terminates with an error).
+        public struct Publisher: Combine.Publisher {
+
+            public typealias Output = Success
+
+            /// The result to deliver to each subscriber.
+            public let result: Result
+
+            /// Creates a publisher that delivers the specified result.
+            ///
+            /// If the result is `.success`, the `Once` publisher sends the specified
+            /// output to all subscribers and finishes normally. If the result is
+            /// `.failure`, then the publisher fails immediately with the specified
+            /// error.
+            ///
+            /// - Parameter result: The result to deliver to each subscriber.
+            public init(_ result: Result) {
+                self.result = result
+            }
+
+            /// Creates a publisher that sends the specified output to all subscribers and
+            /// finishes normally.
+            ///
+            /// - Parameter output: The output to deliver to each subscriber.
+            public init(_ output: Output) {
+                self.init(.success(output))
+            }
+
+            /// Creates a publisher that immediately terminates upon subscription with
+            /// the given failure.
+            ///
+            /// - Parameter failure: The failure to send when terminating.
+            public init(_ failure: Failure) {
+                self.init(.failure(failure))
+            }
+
+            public func receive<Downstream: Subscriber>(subscriber: Downstream)
+                where Downstream.Input == Success, Downstream.Failure == Failure
+            {
+                switch result {
+                case .success(let value):
+                    subscriber.receive(subscription: Inner(value: value,
+                                                           downstream: subscriber))
+                case .failure(let failure):
+                    subscriber.receive(subscription: Subscriptions.empty)
+                    subscriber.receive(completion: .failure(failure))
+                }
+            }
+        }
+    }
+
+    public var ocombine: OCombine {
+        return OCombine(self)
+    }
+
+#if !canImport(Combine)
+    /// A publisher that publishes an output to each subscriber exactly once then
+    /// finishes, or fails immediately without producing any elements.
+    ///
+    /// If `result` is `.success`, then `Once` waits until it receives a request for
+    /// at least 1 value before sending the output. If `result` is `.failure`, then `Once`
+    /// sends the failure immediately upon subscription.
+    ///
+    /// In contrast with `Just`, a `Once` publisher can terminate with an error instead of
+    /// sending a value. In contrast with `Optional`, a `Once` publisher always sends one
+    /// value (unless it terminates with an error).
+    public typealias Publisher = OCombine.Publisher
+
+    public var publisher: Publisher {
+        return Publisher(self)
+    }
+#endif
+}
+
+extension Result.OCombine {
+    private final class Inner<Downstream: Subscriber>
+        : Subscription,
+          CustomStringConvertible,
+          CustomReflectable,
+          CustomPlaygroundDisplayConvertible
+        where Downstream.Input == Success, Downstream.Failure == Failure
+    {
+        // NOTE: this class has been audited for thread safety.
+        // Combine doesn't use any locking here.
+
+        private var downstream: Downstream?
+        private let output: Success
+
+        init(value: Success, downstream: Downstream) {
+            self.output = value
+            self.downstream = downstream
+        }
+
+        func request(_ demand: Subscribers.Demand) {
+            demand.assertNonZero()
+            guard let downstream = self.downstream.take() else { return }
+            _ = downstream.receive(output)
+            downstream.receive(completion: .finished)
+        }
+
+        func cancel() {
+            downstream = nil
+        }
+
+        var description: String { return "Once" }
+
+        var customMirror: Mirror {
+            return Mirror(self, unlabeledChildren: CollectionOfOne(output))
+        }
+
+        var playgroundDescription: Any { return description }
+    }
+}
+
+extension Result.OCombine.Publisher: Equatable
+    where Output: Equatable, Failure: Equatable
+{
+}
+
+extension Result.OCombine.Publisher where Output: Equatable {
+
+    public func contains(_ output: Output) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(result.map { $0 == output })
+    }
+
+    public func removeDuplicates() -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+}
+
+extension Result.OCombine.Publisher where Output: Comparable {
+
+    public func min() -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func max() -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+}
+
+extension Result.OCombine.Publisher {
+
+    public func allSatisfy(
+        _ predicate: (Output) -> Bool
+    ) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(result.map(predicate))
+    }
+
+    public func tryAllSatisfy(
+        _ predicate: (Output) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(result.tryMap(predicate))
+    }
+
+    public func contains(
+        where predicate: (Output) -> Bool
+    ) -> Result<Bool, Failure>.OCombine.Publisher {
+        return .init(result.map(predicate))
+    }
+
+    public func tryContains(
+        where predicate: (Output) throws -> Bool
+    ) -> Result<Bool, Error>.OCombine.Publisher {
+        return .init(result.tryMap(predicate))
+    }
+
+    public func collect() -> Result<[Output], Failure>.OCombine.Publisher {
+        return .init(result.map { [$0] })
+    }
+
+    public func min(
+        by areInIncreasingOrder: (Output, Output) -> Bool
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func tryMin(
+        by areInIncreasingOrder: (Output, Output) throws -> Bool
+    ) -> Result<Output, Error>.OCombine.Publisher {
+        return .init(result.tryMap { _ = try areInIncreasingOrder($0, $0); return $0 })
+    }
+
+    public func max(
+        by areInIncreasingOrder: (Output, Output
+    ) -> Bool) -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func tryMax(
+        by areInIncreasingOrder: (Output, Output) throws -> Bool
+    ) -> Result<Output, Error>.OCombine.Publisher {
+        return .init(result.tryMap { _ = try areInIncreasingOrder($0, $0); return $0 })
+    }
+
+    public func count() -> Result<Int, Failure>.OCombine.Publisher {
+        return .init(result.map { _ in 1 })
+    }
+
+    public func first() -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func last() -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func ignoreOutput() -> Empty<Output, Failure> {
+        return .init()
+    }
+
+    public func map<ElementOfResult>(
+        _ transform: (Output) -> ElementOfResult
+    ) -> Result<ElementOfResult, Failure>.OCombine.Publisher {
+        return .init(result.map(transform))
+    }
+
+    public func tryMap<ElementOfResult>(
+        _ transform: (Output) throws -> ElementOfResult
+    ) -> Result<ElementOfResult, Error>.OCombine.Publisher {
+        return .init(result.tryMap(transform))
+    }
+
+    public func mapError<TransformedFailure: Error>(
+        _ transform: (Failure) -> TransformedFailure
+    ) -> Result<Output, TransformedFailure>.OCombine.Publisher {
+        return .init(result.mapError(transform))
+    }
+
+    public func removeDuplicates(
+        by predicate: (Output, Output) -> Bool
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func tryRemoveDuplicates(
+        by predicate: (Output, Output) throws -> Bool
+    ) -> Result<Output, Error>.OCombine.Publisher {
+        return .init(result.tryMap { _ = try predicate($0, $0); return $0 })
+    }
+
+    public func replaceError(
+        with output: Output
+    ) -> Result<Output, Never>.OCombine.Publisher {
+        return .init(.success(result.unwrapOr(output)))
+    }
+
+    public func replaceEmpty(
+        with output: Output
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func retry(_ times: Int) -> Result<Output, Failure>.OCombine.Publisher {
+        return self
+    }
+
+    public func reduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: (Accumulator, Output) -> Accumulator
+    ) -> Result<Accumulator, Failure>.OCombine.Publisher {
+        return .init(result.map { nextPartialResult(initialResult, $0) })
+    }
+
+    public func tryReduce<Accumulator>(
+        _ initialResult: Accumulator,
+        _ nextPartialResult: (Accumulator, Output) throws -> Accumulator
+    ) -> Result<Accumulator, Error>.OCombine.Publisher{
+        return .init(result.tryMap { try nextPartialResult(initialResult, $0) })
+    }
+
+    public func scan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult: (ElementOfResult, Output) -> ElementOfResult
+    ) -> Result<ElementOfResult, Failure>.OCombine.Publisher {
+        return .init(result.map { nextPartialResult(initialResult, $0) })
+    }
+
+    public func tryScan<ElementOfResult>(
+        _ initialResult: ElementOfResult,
+        _ nextPartialResult: (ElementOfResult, Output) throws -> ElementOfResult
+    ) -> Result<ElementOfResult, Error>.OCombine.Publisher {
+        return .init(result.tryMap { try nextPartialResult(initialResult, $0) })
+    }
+}
+
+extension Result.OCombine.Publisher where Failure == Never {
+
+    public func setFailureType<Failure: Error>(
+        to failureType: Failure.Type
+    ) -> Result<Output, Failure>.OCombine.Publisher {
+        return .init(result.success)
+    }
+}

package/Sources/Combine/Result.swift

@@ -0,0 +1,46 @@
+//
+//  Result.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 17.06.2019.
+//
+
+extension Result {
+
+    internal func tryMap<NewSuccess>(
+        _ transform: (Success) throws -> NewSuccess
+    ) -> Result<NewSuccess, Error> {
+        switch self {
+        case .success(let success):
+            do {
+                return try .success(transform(success))
+            } catch {
+                return .failure(error)
+            }
+        case .failure(let error):
+            return .failure(error)
+        }
+    }
+
+    internal func unwrapOr(_ handleError: (Failure) -> Success) -> Success {
+        switch self {
+        case .success(let success):
+            return success
+        case .failure(let error):
+            return handleError(error)
+        }
+    }
+
+    internal func unwrapOr(_ handleError: @autoclosure () -> Success) -> Success {
+        return unwrapOr { _ in handleError() }
+    }
+}
+
+extension Result where Failure == Never {
+    internal var success: Success {
+        switch self {
+        case .success(let success):
+            return success
+        }
+    }
+}