Merge pull request #37 from ishkawa/feature/inputs-subject

Add inputs subject to bind action trigger with arbitrary observables

Author: ashfurrow

Action.podspec

@@ -21,8 +21,8 @@ Pod::Spec.new do |s|
   s.source_files  = "*.{swift}"
 
   s.frameworks  = "Foundation"
-  s.dependency "RxSwift", '~> 2.0'
-  s.dependency "RxCocoa", '~> 2.0'
+  s.dependency "RxSwift", '~> 2.6'
+  s.dependency "RxCocoa", '~> 2.6'
 
   s.watchos.exclude_files = "UIButton+Rx.swift", "UIBarButtonItem+Action.swift", "AlertAction.swift"
   s.osx.exclude_files = "UIButton+Rx.swift", "UIBarButtonItem+Action.swift", "AlertAction.swift"

Action.swift

@@ -18,6 +18,13 @@ public final class Action<Input, Element> {
     public let _enabledIf: Observable<Bool>
     public let workFactory: WorkFactory
 
+    /// Inputs that triggers execution of action.
+    /// This subject also includes inputs as aguments of execute().
+    /// All inputs are always appear in this subject even if the action is not enabled.
+    /// Thus, inputs count equals elements count + errors count.
+    public let inputs = PublishSubject<Input>()
+    private let _completed = PublishSubject<Void>()
+
     /// Errors aggrevated from invocations of execute(). 
     /// Delivered on whatever scheduler they were sent from.
     public var errors: Observable<ActionError> {
@@ -67,6 +74,12 @@ public final class Action<Input, Element> {
         Observable.combineLatest(self._enabledIf, self.executing) { (enabled, executing) -> Bool in
             return enabled && !executing
         }.bindTo(_enabled).addDisposableTo(disposeBag)
+
+        self.inputs
+            .subscribeNext { [weak self] input in
+                self?._execute(input)
+            }
+            .addDisposableTo(disposeBag)
     }
 }
 
@@ -83,6 +96,29 @@ public extension Action {
 public extension Action {
 
     public func execute(input: Input) -> Observable<Element> {
+        let buffer = ReplaySubject<Element>.createUnbounded()
+        let error = errors
+            .flatMap { error -> Observable<Element> in
+                if case .UnderlyingError(let error) = error {
+                    throw error
+                } else {
+                    return Observable.empty()
+                }
+            }
+        
+        Observable
+            .of(elements, error)
+            .merge()
+            .takeUntil(_completed)
+            .bindTo(buffer)
+            .addDisposableTo(disposeBag)
+        
+        inputs.onNext(input)
+        
+        return buffer.asObservable()
+    }
+
+    private func _execute(input: Input) -> Observable<Element> {
 
         // Buffer from the work to a replay subject.
         let buffer = ReplaySubject<Element>.createUnbounded()
@@ -119,7 +155,9 @@ public extension Action {
                 onError: {[weak self] error in
                     self?._errors.onNext(ActionError.UnderlyingError(error))
                 },
-                onCompleted: nil,
+                onCompleted: {[weak self] in
+                    self?._completed.onNext()
+                },
                 onDisposed: {[weak self] in
                     self?.doLocked { self?._executing.value = false }
                 })

Changelog.md

@@ -4,6 +4,7 @@ Changelog
 Current master
 --------------
 
+- Added inputs subject to trigger actins by observables. See [#37](https://github.com/RxSwiftCommunity/Action/pull/37).
 - Fixes a problem with observable deallocation related to `rx_action` button property. See [#33](https://github.com/RxSwiftCommunity/Action/pull/33).
 - Improved Carthage compatibility. See [#34](https://github.com/RxSwiftCommunity/Action/pull/34).
 

Demo/Demo.xcodeproj/project.pbxproj

@@ -160,16 +160,35 @@ class ActionTests: QuickSpec {
                 testItems = context()["items"] as! [String]
             }
 
-            it("sends next elements on elements observable") {
+            it("sends next elements on inputs and elements observables when execute() is called") {
                 let subject = testSubject(testItems)
-                var receivedElements: [String] = []
 
+                var receivedInputs: [Void] = []
+                subject.inputs.subscribeNext { (input) -> Void in
+                    receivedInputs += [input]
+                    }.addDisposableTo(disposeBag)
+
+                var receivedElements: [String] = []
                 subject.elements.subscribeNext { (element) -> Void in
                     receivedElements += [element]
                     }.addDisposableTo(disposeBag)
 
                 subject.execute()
 
+                expect(receivedInputs.count) == 1
+                expect(receivedElements) == testItems
+            }
+
+            it("sends next elements on elements observable when inputs receives next elements") {
+                let subject = testSubject(testItems)
+                var receivedElements: [String] = []
+
+                subject.elements.subscribeNext { (element) -> Void in
+                    receivedElements += [element]
+                    }.addDisposableTo(disposeBag)
+
+                subject.inputs.onNext()
+
                 expect(receivedElements) == testItems
             }
 
@@ -235,102 +254,122 @@ class ActionTests: QuickSpec {
             expect(invocations) == 1
         }
 
-        describe("enabled") {
-            it("sends true on the enabled observable") {
-                let subject = emptySubject()
+        sharedExamples("triggering execution") { (context: QCKDSLSharedExampleContext!) -> Void in
+            var executer: TestActionExecuter!
 
-                let enabled = try! subject.enabled.toBlocking().first()
-                expect(enabled) == true
+            beforeEach {
+                executer = context()["executer"] as! TestActionExecuter
             }
 
-            it("is externally disabled while executing") {
-                var observer: AnyObserver<Void>!
-                let subject = Action<Void, Void>(workFactory: { _ in
-                    return Observable.create { (obsv) -> Disposable in
-                        observer = obsv
-                        return NopDisposable.instance
-                    }
-                })
+            describe("enabled") {
+                it("sends true on the enabled observable") {
+                    let subject = emptySubject()
 
-                subject.execute()
+                    let enabled = try! subject.enabled.toBlocking().first()
+                    expect(enabled) == true
+                }
 
-                var enabled = try! subject.enabled.toBlocking().first()
-                expect(enabled) == false
+                it("is externally disabled while executing") {
+                    var observer: AnyObserver<Void>!
+                    let subject = Action<Void, Void>(workFactory: { _ in
+                        return Observable.create { (obsv) -> Disposable in
+                            observer = obsv
+                            return NopDisposable.instance
+                        }
+                    })
 
-                observer.onCompleted()
+                    executer.execute(subject)
 
-                enabled = try! subject.enabled.toBlocking().first()
-                expect(enabled) == true
-            }
-        }
+                    var enabled = try! subject.enabled.toBlocking().first()
+                    expect(enabled) == false
 
-        describe("disabled") {
-            it("sends false on enabled observable") {
-                let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
-                    return .empty()
-                })
+                    observer.onCompleted()
 
-                let enabled = try! subject.enabled.toBlocking().first()
-                expect(enabled) == false
+                    enabled = try! subject.enabled.toBlocking().first()
+                    expect(enabled) == true
+                }
             }
-            
-            it("errors observable sends error as next event when execute() is called") {
-                let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
-                    return .empty()
-                })
 
-                var receivedError: ActionError?
+            describe("disabled") {
+                it("sends false on enabled observable") {
+                    let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
+                        return .empty()
+                    })
 
-                subject
-                    .errors
-                    .subscribeNext { error in
-                        receivedError = error
-                    }
-                    .addDisposableTo(disposeBag)
+                    let enabled = try! subject.enabled.toBlocking().first()
+                    expect(enabled) == false
+                }
+                
+                it("errors observable sends error as next event when execute() is called") {
+                    let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
+                        return .empty()
+                    })
 
-                subject.execute()
+                    var receivedError: ActionError?
 
-                expect(receivedError).toNot( beNil() )
-            }
+                    subject
+                        .errors
+                        .subscribeNext { error in
+                            receivedError = error
+                        }
+                        .addDisposableTo(disposeBag)
 
-            it("errors observable sends correct error types when execute() is called") {
-                let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
-                    return .empty()
-                })
+                    executer.execute(subject)
 
-                var receivedError: ActionError?
+                    expect(receivedError).toNot( beNil() )
+                }
 
-                subject
-                    .errors
-                    .subscribeNext { error in
-                        receivedError = error
+                it("errors observable sends correct error types when execute() is called") {
+                    let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
+                        return .empty()
+                    })
+
+                    var receivedError: ActionError?
+
+                    subject
+                        .errors
+                        .subscribeNext { error in
+                            receivedError = error
+                        }
+                        .addDisposableTo(disposeBag)
+
+                    executer.execute(subject)
+
+                    guard let error = receivedError else {
+                        fail("Error is nil"); return
                     }
-                    .addDisposableTo(disposeBag)
-                
-                subject.execute()
 
-                guard let error = receivedError else {
-                    fail("Error is nil"); return
+                    if case ActionError.NotEnabled = error {
+                        // Nop
+                    } else {
+                        fail("Incorrect error returned.")
+                    }
                 }
 
-                if case ActionError.NotEnabled = error {
-                    // Nop
-                } else {
-                    fail("Incorrect error returned.")
-                }
-            }
+                it("doesn't invoke the work factory") {
+                    var invoked = false
 
-            it("doesn't invoke the work factory") {
-                var invoked = false
+                    let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
+                        invoked = true
+                        return .empty()
+                    })
 
-                let subject = Action<Void, Void>(enabledIf: .just(false), workFactory: { _ in
-                    invoked = true
-                    return .empty()
-                })
+                    executer.execute(subject)
 
-                subject.execute()
+                    expect(invoked) == false
+                }
+            }
+        }
 
-                expect(invoked) == false
+        describe("execute via execute()") {
+            itBehavesLike("triggering execution") { () -> (NSDictionary) in
+                return ["executer": TestActionExecuter { subject in subject.execute() }]
+            }
+        }
+
+        describe("execute via inputs subject") {
+            itBehavesLike("triggering execution") { () -> (NSDictionary) in
+                return ["executer": TestActionExecuter { subject in subject.inputs.onNext() }]
             }
         }
     }
@@ -378,3 +417,11 @@ func testSubject(elements: [String]) -> Action<Void, String> {
         return elements.toObservable()
     })
 }
+
+class TestActionExecuter {
+    let execute: Action<Void, Void> -> Void
+
+    init(execute: Action<Void, Void> -> Void) {
+        self.execute = execute
+    }
+}

Demo/DemoTests/ActionTests.swift

@@ -1,29 +1,25 @@
 # Uncomment this line to define a global platform for your project
-# platform :ios, '8.0'
-# Uncomment this line if you're using Swift
-
-
-use_frameworks!
-
-inhibit_all_warnings!
+# platform :ios, '9.0'
 
 target 'Demo' do
+  # Comment this line if you're not using Swift and don't want to use dynamic frameworks
+  use_frameworks!
 
-# Action library
-pod 'Action', :path => '../'
+  # Action library
+  pod 'Action', :path => '../'
 
-end
-
-target 'DemoTests' do
+  target 'DemoTests' do
+    inherit! :search_paths
 
-# Dependencies
-pod 'RxSwift', '~> 2.1'
-pod 'RxCocoa', '~> 2.1'
-pod 'RxBlocking', '~> 2.1'
+    # Dependencies
+    pod 'Action', :path => '../'
+    pod 'RxSwift', '~> 2.6'
+    pod 'RxCocoa', '~> 2.6'
+    pod 'RxBlocking', '~> 2.6'
 
-# Testing libraries
-pod 'Quick'
-pod 'Nimble'
+    # Testing libraries
+    pod 'Quick'
+    pod 'Nimble'
+  end
 
 end
-