`trySend` to `?.on` and cleanup for `tap`

CHANGELOG.md

@@ -11,5 +11,6 @@ All notable changes to this project will be documented in this file.
 * Moved from using `>-` operator to protocol extensions
 * Change from `disposeBag.addDisposable` to `disposable.addDisposableTo`
 * Changes in RxCocoa extensions to enable fluent style
+* Rename of `do*` to `tap*`
 
 ####Fixed

Rx.xcworkspace/contents.xcworkspacedata

@@ -7,6 +7,9 @@
    <FileRef
       location = "group:README.md">
    </FileRef>
+   <FileRef
+      location = "group:CHANGELOG.md">
+   </FileRef>
    <Group
       location = "group:Playgrounds"
       name = "Playgrounds">

RxSwift/RxSwift/Observables/Implementations/Do.swift

@@ -8,35 +8,34 @@
 
 import Foundation
 
-class Do_<O: ObserverType> : Sink<O>, ObserverType {
+class TapSink<O: ObserverType> : Sink<O>, ObserverType {
     typealias Element = O.Element
-    typealias DoType = Do<Element>
+    typealias Parent = Tap<Element>
     
-    let parent: DoType
+    let parent: Parent
     
-    init(parent: DoType, observer: O, cancel: Disposable) {
+    init(parent: Parent, observer: O, cancel: Disposable) {
         self.parent = parent
         super.init(observer: observer, cancel: cancel)
     }
     
     func on(event: Event<Element>) {
-        parent.eventHandler(event).recoverWith { error in
-            // catch clause
-            trySendError(observer, error)
-            self.dispose()
-            return SuccessResult
-        }.flatMap { _ -> RxResult<Void> in
-            trySend(observer, event)
+        do {
+            try parent.eventHandler(event)
+            observer?.on(event)
             if event.isStopEvent {
                 self.dispose()
             }
-            return SuccessResult
+        }
+        catch let error {
+            observer?.on(.Error(error))
+            self.dispose()
         }
     }
 }
 
-class Do<Element> : Producer<Element> {
-    typealias EventHandler = Event<Element> -> RxResult<Void>
+class Tap<Element> : Producer<Element> {
+    typealias EventHandler = Event<Element> throws -> Void
     
     let source: Observable<Element>
     let eventHandler: EventHandler
@@ -47,7 +46,7 @@ class Do<Element> : Producer<Element> {
     }
     
     override func run<O: ObserverType where O.Element == Element>(observer: O, cancel: Disposable, setSink: (Disposable) -> Void) -> Disposable {
-        let sink = Do_(parent: self, observer: observer, cancel: cancel)
+        let sink = TapSink(parent: self, observer: observer, cancel: cancel)
         
         setSink(sink)
         

RxSwift/RxSwift/Observables/Observable+Single.swift

@@ -65,23 +65,18 @@ extension ObservableType {
 // do
 
 extension ObservableType {
-    public func doOrDie(eventHandler: (Event<E>) -> RxResult<Void>)
+    public func tap(eventHandler: (Event<E>) throws -> Void)
         -> Observable<E> {
-        return Do(source: self.normalize(), eventHandler: eventHandler)
-    }
-
-    public func `do`(eventHandler: (Event<E>) -> Void)
-        -> Observable<E> {
-        return Do(source: self.normalize(), eventHandler: { success(eventHandler($0)) })
+        return Tap(source: self.normalize(), eventHandler: eventHandler)
     }
 }
 
 // doOnNext
 
 extension ObservableType {
-    public func doOnNext(actionOnNext: E -> Void)
+    public func tapOnNext(actionOnNext: E -> Void)
         -> Observable<E> {
-        return self.`do` { event in
+        return self.tap { event in
             switch event {
             case .Next(let value):
                 actionOnNext(value)

RxTests/RxSwiftTests/Tests/Observable+MultipleTest.swift

@@ -2520,7 +2520,7 @@ extension ObservableMultipleTest {
         var sourceNotDisposed = false
         
         let res = scheduler.start {
-            l .`do` { _ in sourceNotDisposed = true } .takeUntil(r)
+            l .tap { _ in sourceNotDisposed = true } .takeUntil(r)
         }
         
         XCTAssertEqual(res.messages, [
@@ -2548,7 +2548,7 @@ extension ObservableMultipleTest {
         var sourceNotDisposed = false
         
         let res = scheduler.start {
-            l .takeUntil(r .`do` { _ in sourceNotDisposed = true })
+            l .takeUntil(r .tap { _ in sourceNotDisposed = true })
         }
         
         XCTAssertEqual(res.messages, [

RxTests/RxSwiftTests/Tests/Observable+SingleTest.swift

@@ -288,7 +288,7 @@ extension ObservableSingleTest {
     
         var i = 0
         var sum = 2 + 3 + 4 + 5
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
                 switch e {
                 case .Next(let _):
                     i++
@@ -331,7 +331,7 @@ extension ObservableSingleTest {
             ])
         
         var i = 0
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
             switch e {
             case .Next(_):
                 i++
@@ -373,7 +373,7 @@ extension ObservableSingleTest {
         var i = 0
         var sum = 2 + 3 + 4 + 5
         var completedEvaluation = false
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
             switch e {
             case .Next(let value):
                 i++
@@ -415,7 +415,7 @@ extension ObservableSingleTest {
         
         var i = 0
         var completedEvaluation = false
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
             switch e {
             case .Next(_):
                 i++
@@ -455,7 +455,7 @@ extension ObservableSingleTest {
         var i = 0
         var sum = 2 + 3 + 4 + 5
         var sawError = false
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
             switch e {
             case .Next(let value):
                 i++
@@ -502,7 +502,7 @@ extension ObservableSingleTest {
         var i = 0
         var sum = 2 + 3 + 4 + 5
         var sawError = false
-        let res = scheduler.start { xs.`do` { e in
+        let res = scheduler.start { xs.tap { e in
             switch e {
             case .Next(let value):
                 i++
@@ -534,7 +534,31 @@ extension ObservableSingleTest {
         XCTAssertEqual(xs.subscriptions, correctSubscriptions)
     }
     
-    // ...
+    func testDo_Throws() {
+        let scheduler = TestScheduler(initialClock: 0)
+        
+        let xs = scheduler.createHotObservable([
+            next(150, 1),
+            next(210, 2),
+            completed(250)
+            ])
+        
+        let res = scheduler.start { xs.tap { _ in
+                throw testError
+            }
+        }
+        
+        let correctMessages = [
+            error(210, testError) as Recorded<Int>
+        ]
+        
+        let correctSubscriptions = [
+            Subscription(200, 210)
+        ]
+        
+        XCTAssertEqual(res.messages, correctMessages)
+        XCTAssertEqual(xs.subscriptions, correctSubscriptions)
+    }
 }
 
 // retry