Fixed some issues SwiftLint issues and build test build problems on macOS/tvOS.

All rake targets are running locally! Fingers crossed!

Author: freak4pc

Demo/Demo.xcodeproj/project.pbxproj

@@ -12,7 +12,7 @@ DEPENDENCIES:
 
 EXTERNAL SOURCES:
   RxViewModel:
-    :path: ../
+    :path: "../"
 
 SPEC CHECKSUMS:
   Nimble: 657d000e11df8aebe27cdaf9d244de7f30ed87f7
@@ -22,4 +22,4 @@ SPEC CHECKSUMS:
 
 PODFILE CHECKSUM: 5b740ff0f8e82b1a56bee6decd0acad5bd6013b9
 
-COCOAPODS: 1.3.0.beta.2
+COCOAPODS: 1.2.1

Demo/Podfile.lock

@@ -81,7 +81,8 @@ class RxViewModelSpec: QuickSpec {
       } as Observable<String?>
 
       vm.forwardSignalWhileActive(input).subscribe(onNext: { value in
-        values.append(value!)
+        guard let value = value else { return }
+        values.append(value)
       }, onError: { _ in }, onCompleted: {
         completed = true
       }).disposed(by: self.disposable)
@@ -114,11 +115,13 @@ class RxViewModelSpec: QuickSpec {
       let subject = ReplaySubject<String>.create(bufferSize: 5)
       subject.on(.next("0"))
 
-      vm.throttleSignalWhileInactive(subject).subscribe( onNext: { value in
-        values.append(value)
-      }, onError: { _ in  }, onCompleted: {
-        completed = true
-      }).disposed(by: self.disposable)
+      vm.throttleSignalWhileInactive(subject)
+        .observeOn(MainScheduler.instance)
+        .subscribe(onNext: { value in
+            values.append(value)
+        }, onError: { _ in  }, onCompleted: {
+            completed = true
+        }).disposed(by: self.disposable)
 
       var expectedValues = ["0"]
       expect(values).to(equal(expectedValues))

Demo/Tests/Tests.swift

@@ -26,7 +26,7 @@ def sdks
   return {
     ios: 'iphonesimulator',
     macos: 'macosx',
-    tvos: 'appletvsimulator9.2'
+    tvos: 'appletvsimulator10.2'
   }
 end
 

Rakefile

@@ -37,7 +37,7 @@ returns `true`. Completion and errors are always forwarded immediately.
 */
 extension ObservableType {
   public func throttle(_ interval: TimeInterval, valuesPassingTest predicate: @escaping (E) -> Bool) -> Observable<E> {
-    return Observable.create { (o: AnyObserver<E>) -> Disposable in
+    return Observable.create { (obs: AnyObserver<E>) -> Disposable in
       let disposable = CompositeDisposable()
       let scheduler = ConcurrentDispatchQueueScheduler(qos: .default)
       let nextDisposable = SerialDisposable()
@@ -53,22 +53,22 @@ extension ObservableType {
         - parameter send: 	`Bool` flag indicating where or not the `next` value should be
         «flushed» to the `observable` `o` or not.
         */
-        func flushNext(_ send: Bool) -> Void {
+        func flushNext(_ send: Bool) {
           nextDisposable.dispose()
 
           guard let nV = nextValue, hasNextValue, send else { return }
 
           nextValue = nil
           hasNextValue = false
 
-          o.on(.next(nV))
+          obs.on(.next(nV))
         }
 
         let shouldThrottle = predicate($0)
         flushNext(false)
 
         if !shouldThrottle {
-          o.on(.next($0))
+          obs.on(.next($0))
 
           return
         }
@@ -85,7 +85,6 @@ extension ObservableType {
         _ = disposable.insert(d)
       })
 
-        
       _ = disposable.insert(subscriptionDisposable)
 
       return disposable

Source/Categories/Observable_Operations.swift

@@ -93,17 +93,17 @@ public class RxViewModel: NSObject {
   public func forwardSignalWhileActive<T>(_ observable: Observable<T>) -> Observable<T> {
     let signal = self.activeObservable
 
-    return Observable.create { (o: AnyObserver<T>) -> Disposable in
+    return Observable.create { (obs: AnyObserver<T>) -> Disposable in
       let disposable = CompositeDisposable()
       var signalDisposable: Disposable? = nil
       var disposeKey: CompositeDisposable.DisposeKey?
 
       let activeDisposable = signal.subscribe( onNext: { active in
         if active == true {
           signalDisposable = observable.subscribe( onNext: { value in
-            o.on(.next(value))
+            obs.on(.next(value))
             }, onError: { error in
-              o.on(.error(error))
+              obs.on(.error(error))
             }, onCompleted: {})
 
           if let sd = signalDisposable { disposeKey = disposable.insert(sd) }
@@ -116,12 +116,11 @@ public class RxViewModel: NSObject {
           }
         }
       }, onError: { error in
-        o.on(.error(error))
+        obs.on(.error(error))
       }, onCompleted: {
-        o.on(.completed)
+        obs.on(.completed)
       })
 
-
       _ = disposable.insert(activeDisposable)
 
       return disposable
@@ -143,19 +142,18 @@ public class RxViewModel: NSObject {
   is deallocated.
   */
   public func throttleSignalWhileInactive<T>(_ observable: Observable<T>) -> Observable<T> {
-//    observable.replay(1)
     let result = ReplaySubject<T>.create(bufferSize: 1)
 
-    let activeSignal = self.activeObservable.takeUntil(Observable.create { (o: AnyObserver<T>) -> Disposable in
+    let activeSignal = self.activeObservable.takeUntil(Observable.create { (_: AnyObserver<T>) -> Disposable in
       observable.subscribe(onCompleted: {
         defer { result.dispose() }
 
         result.on(.completed)
       })
     })
 
-    let _ = Observable.combineLatest(activeSignal, observable) { (active, o) -> (Bool?, T) in (active, o) }
-      .throttle(throttleTime) { (active: Bool?, value: T) -> Bool in
+    _ = Observable.combineLatest(activeSignal, observable) { (active, obs) -> (Bool?, T) in (active, obs) }
+      .throttle(throttleTime) { (active: Bool?, _: T) -> Bool in
       return active == false
     }.subscribe(onNext: { (value: (Bool?, T)) in
       result.on(.next(value.1))