Merge pull request #188 from MortMerr/feature/applySingle

[feature/applySingle] implement apply for SingleTrait #trivial

Author: freak4pc

CHANGELOG.md

@@ -8,6 +8,7 @@ master
 - added `toSortedArray` operator
 - rolled `map(to:)` back to `mapTo(_:)` for `SharedSequenceConvertibleType`
 - added `unwrap()` operator for SharedSequence
+- added `apply(_:)` for `Single`
 
 3.3.0
 -----

Playground/RxSwiftExtPlayground.playground/Pages/apply.xcplaygroundpage/Contents.swift

@@ -26,14 +26,24 @@ func addOne(input: Observable<Int>) -> Observable<String> {
         .map { "The next number is \($0)" }
 }
 
+func addOne(input: Single<Int>) -> Single<String> {
+    return input
+        .map { $0 + 1 }
+        .map { "The next number is \($0)" }
+}
+
 example("apply a transformation") {
     let numbers1 = Observable.from([1, 2, 3])
     let numbers2 = Observable.from([100, 101, 102])
+    let number3 = Single.just(1)
+    let number4 = Single.just(100)
 
     print("apply() calls the transform function on the Observable sequence: ")
 
     let transformed1 = numbers1.apply(addOne)
     let transformed2 = numbers2.apply(addOne)
+    let transformed3 = number3.apply(addOne)
+    let transformed4 = number4.apply(addOne)
 
     transformed1.subscribe(onNext: { result in
         print(result)
@@ -42,6 +52,14 @@ example("apply a transformation") {
     transformed2.subscribe(onNext: { result in
         print(result)
     })
+    
+    transformed3.subscribe(onSuccess: { result in
+        print(result)
+    })
+    
+    transformed4.subscribe(onSuccess: { result in
+        print(result)
+    })
 }
 
 //: [Next](@next)

Source/RxSwift/apply.swift

@@ -15,3 +15,10 @@ extension ObservableType {
         return transform(self.asObservable())
     }
 }
+
+extension PrimitiveSequenceType where TraitType == SingleTrait {
+    /// Apply a transformation function to the Single.
+    public func apply<T>(_ transform: (Single<Self.ElementType>) -> Single<T>) -> Single<T> {
+        return transform(self.primitiveSequence)
+    }
+}

Tests/RxSwift/applyTests.swift

@@ -29,6 +29,10 @@ class ApplyTests: XCTestCase {
             .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]
@@ -52,12 +56,37 @@ 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 = [
+            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]
@@ -83,4 +112,25 @@ class ApplyTests: XCTestCase {
 
         XCTAssertEqual(observer.events, correct)
     }
+    
+    func testApplyTransformingTypeSingle() {
+        let value = -7
+        
+        let scheduler = TestScheduler(initialClock: 0)
+        let observer = scheduler.createObserver(String.self)
+        
+        _ = Single.just(value)
+            .apply(transformToString)
+            .asObservable()
+            .subscribe(observer)
+        
+        scheduler.start()
+        
+        let correct = [
+            next(0, "-7"),
+            completed(0)
+        ]
+        
+        XCTAssertEqual(observer.events, correct)
+    }
 }