Add apply for Single, Maybe & Completable (#222)

Author: M0rtyMerr

CHANGELOG.md

@@ -7,6 +7,7 @@ Changelog
 - `once` now uses a `NSRecursiveLock` instead of the deprecated `OSAtomicOr32OrigBarrier`
 - added `merge(with:)` for `Observable`
 - removed `flatMapSync` operator
+- added `apply` for `Completable` and `Maybe` 
 - added `mapTo` for `Single` and `Maybe`
 - added SPM support
 

Source/RxSwift/apply.swift

@@ -16,9 +16,10 @@ extension ObservableType {
     }
 }
 
-extension PrimitiveSequenceType where Trait == SingleTrait {
-    /// Apply a transformation function to the Single.
-    public func apply<T>(_ transform: (Single<Element>) -> Single<T>) -> Single<T> {
+extension PrimitiveSequenceType {
+    /// Apply a transformation function to the primitive sequence.
+    public func apply<Result>(_ transform: (PrimitiveSequence<Trait, Element>) -> PrimitiveSequence<Trait, Result>)
+        -> PrimitiveSequence<Trait, Result> {
         return transform(self.primitiveSequence)
     }
 }

Tests/RxSwift/applyTests.swift

@@ -14,26 +14,12 @@ import RxTest
 
 class ApplyTests: XCTestCase {
 
-    override func setUp() {
-        super.setUp()
-        // Put setup code here. This method is called before the invocation of each test method in the class.
-    }
-
-    override func tearDown() {
-        // Put teardown code here. This method is called after the invocation of each test method in the class.
-        super.tearDown()
-    }
-
     func transform(input: Observable<Int>) -> Observable<Int> {
         return input
             .filter { $0 > 0 }
             .map { $0 * $0 }
     }
 
-    private func transform(input: Single<Int>) -> Single<Int> {
-        return input.map { $0 * $0 }
-    }
-
     func testApply() {
         let values = [0, 42, -7, 100, 1000, 1]
 
@@ -57,36 +43,12 @@ class ApplyTests: XCTestCase {
         XCTAssertEqual(observer.events, correct)
     }
 
-    func testApplySingle() {
-        let value = 10
-        let scheduler = TestScheduler(initialClock: 0)
-        let observer = scheduler.createObserver(Int.self)
-
-        _ = Single.just(value)
-            .apply(transform)
-            .asObservable()
-            .subscribe(observer)
-
-        scheduler.start()
-
-        let correct = Recorded.events([
-            .next(0, 10*10),
-            .completed(0)
-        ])
-
-        XCTAssertEqual(observer.events, correct)
-    }
-
     func transformToString(input: Observable<Int>) -> Observable<String> {
         return input
             .distinctUntilChanged()
             .map { String(describing: $0) }
     }
 
-    func transformToString(input: Single<Int>) -> Single<String> {
-        return input.map(String.init)
-    }
-
     func testApplyTransformingType() {
         let values = [0, 0, 42, 42, -7, 100, 1000, 1, 1]
 
@@ -111,25 +73,88 @@ class ApplyTests: XCTestCase {
 
         XCTAssertEqual(observer.events, correct)
     }
+}
+
+// MARK: - Single
+extension ApplyTests {
+    private func transformToString(input: Single<Int>) -> Single<String> {
+        return input.map(String.init)
+    }
+
+    private func transform(input: Single<Int>) -> Single<Int> {
+        return input.map { $0 * $0 }
+    }
+
+    func testApplySingle() {
+        // Given
+        let value = 10
+        let scheduler = TestScheduler(initialClock: 0)
+        // When
+        let result = scheduler.start {
+            Single.just(value).apply(self.transform).asObservable()
+        }
+        // Then
+        let correct = Recorded.events([
+            .next(TestScheduler.Defaults.subscribed, 10 * 10),
+            .completed(TestScheduler.Defaults.subscribed)
+        ])
+        XCTAssertEqual(result.events, correct)
+    }
 
     func testApplyTransformingTypeSingle() {
+        // Given
         let value = -7
-
         let scheduler = TestScheduler(initialClock: 0)
-        let observer = scheduler.createObserver(String.self)
+        // When
+        let result = scheduler.start {
+            Single.just(value).apply(self.transformToString).asObservable()
+        }
+        let correct = Recorded.events([
+            .next(TestScheduler.Defaults.subscribed, "-7"),
+            .completed(TestScheduler.Defaults.subscribed)
+        ])
+        XCTAssertEqual(result.events, correct)
+    }
+}
 
-        _ = Single.just(value)
-            .apply(transformToString)
-            .asObservable()
-            .subscribe(observer)
+// MARK: - Maybe
+extension ApplyTests {
+    private func transform(input: Maybe<Int>) -> Maybe<Int> {
+        return input.map { $0 * $0 }
+    }
 
-        scheduler.start()
+    func testApplyMaybe() {
+        // Given
+        let value = 10
+        let scheduler = TestScheduler(initialClock: 0)
+        // When
+        let result = scheduler.start {
+            Maybe.just(value).apply(self.transform).asObservable()
+        }
+        // Then
+        XCTAssertEqual(result.events, Recorded.events([
+            .next(TestScheduler.Defaults.subscribed, value * value),
+            .completed(TestScheduler.Defaults.subscribed)
+        ]))
+    }
+}
 
-        let correct = Recorded.events([
-            .next(0, "-7"),
-            .completed(0)
-        ])
+// MARK: - Completable
+extension ApplyTests {
+    private func transform(input: Completable) -> Completable {
+        return input.do(onError: { print($0) })
+    }
 
-        XCTAssertEqual(observer.events, correct)
+    func testApplyCompletable() {
+        // Given
+        let scheduler = TestScheduler(initialClock: 0)
+        // When
+        let result = scheduler.start {
+            Observable.just(1).ignoreElements().asObservable()
+        }
+        // Then
+        XCTAssertEqual(result.events, Recorded.events([
+            .completed(TestScheduler.Defaults.subscribed)
+        ]))
     }
 }