Swiftlint

.swiftlint.yml

@@ -0,0 +1,14 @@
+included:
+  - Source
+  - Tests
+disabled_rules:
+  - line_length
+identifier_name:
+  min_length: 1
+type_name:
+  excluded: T
+function_body_length: 100
+type_body_length: 500
+cyclomatic_complexity:
+  warning: 15
+  error: 25

Source/RxCocoa/mapTo+RxCocoa.swift

@@ -19,7 +19,7 @@ extension SharedSequenceConvertibleType {
     public func mapTo<R>(_ value: R) -> SharedSequence<SharingStrategy, R> {
         return map { _ in value }
     }
-  
+
     public func map<R>(to value: R) -> SharedSequence<SharingStrategy, R> {
         return map { _ in value }
     }

Source/RxSwift/ObservableType+Weak.swift

@@ -22,26 +22,25 @@ extension ObservableType {
 			method?(obj)(value)
 		}
 	}
-    
+
     fileprivate func weakify<A: AnyObject>(_ obj: A, method: ((A) -> () -> Void)?) -> (() -> Void) {
         return { [weak obj] in
             guard let obj = obj else { return }
             method?(obj)()
         }
     }
-	
+
 	/**
 	Subscribes an event handler to an observable sequence.
 
 	- parameter weak: Weakly referenced object containing the target function.
 	- parameter on: Function to invoke on `weak` for each event in the observable sequence.
 	- returns: Subscription object used to unsubscribe from the observable sequence.
 	*/
-
 	public func subscribe<A: AnyObject>(weak obj: A, _ on: @escaping (A) -> (RxSwift.Event<Self.E>) -> Void) -> Disposable {
 		return self.subscribe(weakify(obj, method: on))
 	}
-	
+
 	/**
 	Subscribes an element handler, an error handler, a completion handler and disposed handler to an observable sequence.
 
@@ -53,23 +52,21 @@ extension ObservableType {
 	gracefully completed, errored, or if the generation is cancelled by disposing subscription)
 	- returns: Subscription object used to unsubscribe from the observable sequence.
 	*/
-
 	public func subscribe<A: AnyObject>(
-		weak obj: A,
-		     onNext: ((A) -> (Self.E) -> Void)? = nil,
-		     onError: ((A) -> (Error) -> Void)? = nil,
-		     onCompleted: ((A) -> () -> Void)? = nil,
-		     onDisposed: ((A) -> () -> Void)? = nil) -> Disposable {
-		
+                    weak obj: A,
+                    onNext: ((A) -> (Self.E) -> Void)? = nil,
+                    onError: ((A) -> (Error) -> Void)? = nil,
+                    onCompleted: ((A) -> () -> Void)? = nil,
+                    onDisposed: ((A) -> () -> Void)? = nil)
+        -> Disposable {
 		let disposable: Disposable
-		
+
 		if let disposed = onDisposed {
 			disposable = Disposables.create(with: weakify(obj, method: disposed))
-		}
-		else {
+		} else {
 			disposable = Disposables.create()
 		}
-		
+
 		let observer = AnyObserver { [weak obj] (e: RxSwift.Event<Self.E>) in
 			guard let obj = obj else { return }
 			switch e {
@@ -83,42 +80,39 @@ extension ObservableType {
 				disposable.dispose()
 			}
 		}
-		
+
 		return Disposables.create(self.asObservable().subscribe(observer), disposable)
 	}
-	
+
 	/**
 	Subscribes an element handler to an observable sequence.
 
 	- parameter weak: Weakly referenced object containing the target function.
 	- parameter onNext: Function to invoke on `weak` for each element in the observable sequence.
 	- returns: Subscription object used to unsubscribe from the observable sequence.
 	*/
-
 	public func subscribeNext<A: AnyObject>(weak obj: A, _ onNext: @escaping (A) -> (Self.E) -> Void) -> Disposable {
         return self.subscribe(onNext: weakify(obj, method: onNext))
 	}
-	
+
 	/**
 	Subscribes an error handler to an observable sequence.
 
 	- parameter weak: Weakly referenced object containing the target function.
 	- parameter onError: Function to invoke on `weak` upon errored termination of the observable sequence.
 	- returns: Subscription object used to unsubscribe from the observable sequence.
 	*/
-
 	public func subscribeError<A: AnyObject>(weak obj: A, _ onError: @escaping (A) -> (Error) -> Void) -> Disposable {
         return self.subscribe(onError: weakify(obj, method: onError))
 	}
-	
+
 	/**
 	Subscribes a completion handler to an observable sequence.
 
 	- parameter weak: Weakly referenced object containing the target function.
 	- parameter onCompleted: Function to invoke on `weak` graceful termination of the observable sequence.
 	- returns: Subscription object used to unsubscribe from the observable sequence.
 	*/
-
 	public func subscribeCompleted<A: AnyObject>(weak obj: A, _ onCompleted: @escaping (A) -> () -> Void) -> Disposable {
         return self.subscribe(onCompleted: weakify(obj, method: onCompleted))
 	}

Source/RxSwift/cascade.swift

@@ -10,9 +10,9 @@ import Foundation
 import RxSwift
 
 extension Observable where Element : ObservableType {
-	
+
 	public typealias T = Element.E
-	
+
 	/**
 	Cascade through a sequence of observables: every observable that sends a `next` value becomes the "current"
 	observable (like in `switchLatest`), and the subscription to all previous observables in the sequence is disposed.
@@ -23,96 +23,88 @@ extension Observable where Element : ObservableType {
 	- parameter observables: a sequence of observables which will all be immediately subscribed to
 	- returns: An observable sequence that contains elements from the latest observable sequence that emitted elements
 	*/
-
-
-	public static func cascade<S : Sequence>(_ observables : S) -> Observable<T> where S.Iterator.Element == Element {
-		let flow = Array(observables)
-		if flow.isEmpty {
-			return Observable<T>.empty()
-		}
-
-		return Observable<T>.create { observer in
-			var current = 0, initialized = false
-			var subscriptions: [SerialDisposable?] = flow.map { _ in SerialDisposable() }
-
-			let lock = NSRecursiveLock()
-			lock.lock()
-			defer { lock.unlock() }
-
-			for i in 0 ..< flow.count {
-				let index = i
-				let disposable = flow[index].subscribe { event in
-					lock.lock()
-					defer { lock.unlock() }
-
-					switch event {
-					case .next(let element):
-						while current < index {
-							subscriptions[current]?.dispose()
-							subscriptions[current] = nil
-							current += 1
-						}
-						if index == current {
-							assert(subscriptions[index] != nil)
-							observer.onNext(element)
-						}
-
-					case .completed:
-						if index >= current {
-							if (initialized) {
-								subscriptions[index]?.dispose()
-								subscriptions[index] = nil
-								for next in current ..< subscriptions.count {
-									if subscriptions[next] != nil {
-										return
-									}
-								}
-								observer.onCompleted()
-							}
-						}
-
-					case .error(let error):
-						observer.onError(error)
-					}
-				}
-				if let serialDisposable = subscriptions[index] {
-					serialDisposable.disposable = disposable
-				} else {
-					disposable.dispose()
-				}
-			}
-
-			initialized = true
-
-			for i in 0 ..< flow.count {
-				if subscriptions[i] != nil {
-					return Disposables.create {
-						subscriptions.forEach { $0?.dispose() }
-					}
-				}
-			}
-
-			observer.onCompleted()
-			return Disposables.create()
-		}
+	public static func cascade<S: Sequence>(_ observables: S) -> Observable<T> where S.Iterator.Element == Element {
+        let flow = Array(observables)
+        if flow.isEmpty {
+            return Observable<T>.empty()
+        }
+
+        return Observable<T>.create { observer in
+            var current = 0, initialized = false
+            var subscriptions: [SerialDisposable?] = flow.map { _ in SerialDisposable() }
+
+            let lock = NSRecursiveLock()
+            lock.lock()
+            defer { lock.unlock() }
+
+            for i in 0 ..< flow.count {
+                let index = i
+                let disposable = flow[index].subscribe { event in
+                    lock.lock()
+                    defer { lock.unlock() }
+
+                    switch event {
+                    case .next(let element):
+                        while current < index {
+                            subscriptions[current]?.dispose()
+                            subscriptions[current] = nil
+                            current += 1
+                        }
+                        if index == current {
+                            assert(subscriptions[index] != nil)
+                            observer.onNext(element)
+                        }
+
+                    case .completed:
+                        if index >= current {
+                            if initialized {
+                                subscriptions[index]?.dispose()
+                                subscriptions[index] = nil
+                                for next in current ..< subscriptions.count where subscriptions[next] != nil {
+                                    return
+                                }
+                                observer.onCompleted()
+                            }
+                        }
+
+                    case .error(let error):
+                        observer.onError(error)
+                    }
+                }
+                if let serialDisposable = subscriptions[index] {
+                    serialDisposable.disposable = disposable
+                } else {
+                    disposable.dispose()
+                }
+            }
+
+            initialized = true
+
+            for i in 0 ..< flow.count where subscriptions[i] != nil {
+                return Disposables.create {
+                    subscriptions.forEach { $0?.dispose() }
+                }
+            }
+
+            observer.onCompleted()
+            return Disposables.create()
+        }
 	}
 }
 
 extension ObservableType {
-
-	/**
-	Cascade through a sequence of observables: every observable that sends a `next` value becomes the "current"
-	observable (like in `switchLatest`), and the subscription to all previous observables in the sequence is disposed.
-
-	This allows subscribing to multiple observable sequences while irrevocably switching to the next when it starts emitting. If any of the
-	currently subscribed-to sequences errors, the error is propagated to the observer and the sequence terminates.
-
-	- parameter observables: a sequence of observables which will all be immediately subscribed to
-	- returns: An observable sequence that contains elements from the latest observable sequence that emitted elements
-	*/
-
-	public func cascade<S : Sequence>(_ next : S) -> Observable<E> where S.Iterator.Element == Self {
-		return Observable.cascade([self.asObservable()] + Array(next).map { $0.asObservable() })
-	}
-
+
+    /**
+    Cascade through a sequence of observables: every observable that sends a `next` value becomes the "current"
+    observable (like in `switchLatest`), and the subscription to all previous observables in the sequence is disposed.
+
+    This allows subscribing to multiple observable sequences while irrevocably switching to the next when it starts emitting. If any of the
+    currently subscribed-to sequences errors, the error is propagated to the observer and the sequence terminates.
+
+    - parameter observables: a sequence of observables which will all be immediately subscribed to
+    - returns: An observable sequence that contains elements from the latest observable sequence that emitted elements
+    */
+    public func cascade<S: Sequence>(_ next: S) -> Observable<E> where S.Iterator.Element == Self {
+        return Observable.cascade([self.asObservable()] + Array(next).map { $0.asObservable() })
+    }
 }

Source/RxSwift/catchErrorJustComplete.swift

@@ -8,7 +8,6 @@
 
 import RxSwift
 
-
 extension ObservableType {
     /**
      Dismiss errors and complete the sequence instead