Merge pull request #47 from ishkawa/swift-3

Converting to Swift 3 (take 2)

Author: ashfurrow

Action.swift

@@ -6,14 +6,14 @@ import RxCocoa
 public typealias CocoaAction = Action<Void, Void>
 
 /// Possible errors from invoking execute()
-public enum ActionError: ErrorType {
-    case NotEnabled
-    case UnderlyingError(ErrorType)
+public enum ActionError: Error {
+    case notEnabled
+    case underlyingError(Error)
 }
 
 /// TODO: Add some documentation.
 public final class Action<Input, Element> {
-    public typealias WorkFactory = Input -> Observable<Element>
+    public typealias WorkFactory = (Input) -> Observable<Element>
 
     public let _enabledIf: Observable<Bool>
     public let workFactory: WorkFactory
@@ -23,83 +23,73 @@ public final class Action<Input, Element> {
     /// 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>()
+    fileprivate let _completed = PublishSubject<Void>()
 
     /// Errors aggrevated from invocations of execute(). 
     /// Delivered on whatever scheduler they were sent from.
     public var errors: Observable<ActionError> {
         return self._errors.asObservable()
     }
-    private let _errors = PublishSubject<ActionError>()
+    fileprivate let _errors = PublishSubject<ActionError>()
 
     /// Whether or not we're currently executing. 
     /// Delivered on whatever scheduler they were sent from.
     public var elements: Observable<Element> {
         return self._elements.asObservable()
     }
-    private let _elements = PublishSubject<Element>()
+    fileprivate let _elements = PublishSubject<Element>()
 
     /// Whether or not we're currently executing. 
     /// Always observed on MainScheduler.
     public var executing: Observable<Bool> {
         return self._executing.asObservable().observeOn(MainScheduler.instance)
     }
-    private let _executing = Variable(false)
+    fileprivate let _executing = Variable(false)
 
     /// Observables returned by the workFactory.
     /// Useful for sending results back from work being completed
     /// e.g. response from a network call.
     public var executionObservables: Observable<Observable<Element>> {
         return self._executionObservables.asObservable().observeOn(MainScheduler.instance)
     }
-    private let _executionObservables = PublishSubject<Observable<Element>>()
+    fileprivate let _executionObservables = PublishSubject<Observable<Element>>()
 
     /// Whether or not we're enabled. Note that this is a *computed* sequence
     /// property based on enabledIf initializer and if we're currently executing.
     /// Always observed on MainScheduler.
     public var enabled: Observable<Bool> {
         return _enabled.asObservable().observeOn(MainScheduler.instance)
     }
-    public private(set) var _enabled = BehaviorSubject(value: true)
+    public fileprivate(set) var _enabled = BehaviorSubject(value: true)
 
-    private let executingQueue = dispatch_queue_create("com.ashfurrow.Action.executingQueue", DISPATCH_QUEUE_SERIAL)
-    private let disposeBag = DisposeBag()
+    fileprivate let executingQueue = DispatchQueue(label: "com.ashfurrow.Action.executingQueue", attributes: [])
+    fileprivate let disposeBag = DisposeBag()
 
-    public init<B: BooleanType>(enabledIf: Observable<B>, workFactory: WorkFactory) {
-        self._enabledIf = enabledIf.map { booleanType in
-            return booleanType.boolValue
-        }
+    public init(enabledIf: Observable<Bool> = Observable.just(true), workFactory: @escaping WorkFactory) {
+        self._enabledIf = enabledIf
+        
         self.workFactory = workFactory
 
         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)
+        self.inputs.subscribe(onNext: { [weak self] (input) in
+            self?._execute(input)
+        }).addDisposableTo(disposeBag)
     }
 }
 
-// MARK: Convenience initializers.
-public extension Action {
-
-    /// Always enabled.
-    public convenience init(workFactory: WorkFactory) {
-        self.init(enabledIf: .just(true), workFactory: workFactory)
-    }
-}
 
 // MARK: Execution!
 public extension Action {
 
-    public func execute(input: Input) -> Observable<Element> {
+    @discardableResult
+    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 {
+                if case .underlyingError(let error) = error {
                     throw error
                 } else {
                     return Observable.empty()
@@ -118,7 +108,8 @@ public extension Action {
         return buffer.asObservable()
     }
 
-    private func _execute(input: Input) -> Observable<Element> {
+    @discardableResult
+    fileprivate func _execute(_ input: Input) -> Observable<Element> {
 
         // Buffer from the work to a replay subject.
         let buffer = ReplaySubject<Element>.createUnbounded()
@@ -134,7 +125,7 @@ public extension Action {
 
         // Make sure we started executing and we're accidentally disabled.
         guard startedExecuting else {
-            let error = ActionError.NotEnabled
+            let error = ActionError.notEnabled
             self._errors.onNext(error)
             buffer.onError(error)
 
@@ -153,7 +144,7 @@ public extension Action {
                     self?._elements.onNext(element)
                 },
                 onError: {[weak self] error in
-                    self?._errors.onNext(ActionError.UnderlyingError(error))
+                    self?._errors.onNext(ActionError.underlyingError(error))
                 },
                 onCompleted: {[weak self] in
                     self?._completed.onNext()
@@ -169,12 +160,12 @@ public extension Action {
 }
 
 private extension Action {
-    private func doLocked(closure: () -> Void) {
-        dispatch_sync(executingQueue, closure)
+    func doLocked(_ closure: () -> Void) {
+        executingQueue.sync(execute: closure)
     }
 }
 
-internal extension BehaviorSubject where Element: BooleanLiteralConvertible {
+internal extension BehaviorSubject where Element: ExpressibleByBooleanLiteral {
     var valueOrFalse: Element {
         guard let value = try? value() else { return false }
 

Action.xcodeproj/project.pbxproj

@@ -434,7 +434,6 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 2.3;
 			};
 			name = Debug;
 		};
@@ -449,7 +448,6 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = "-.Tests";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 2.3;
 			};
 			name = Release;
 		};
@@ -464,7 +462,6 @@
 				PRODUCT_BUNDLE_IDENTIFIER = "-.Demo";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
-				SWIFT_VERSION = 2.3;
 			};
 			name = Debug;
 		};
@@ -478,7 +475,6 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
 				PRODUCT_BUNDLE_IDENTIFIER = "-.Demo";
 				PRODUCT_NAME = "$(TARGET_NAME)";
-				SWIFT_VERSION = 2.3;
 			};
 			name = Release;
 		};
@@ -527,6 +523,7 @@
 				ONLY_ACTIVE_ARCH = YES;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 3.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 				VERSIONING_SYSTEM = "apple-generic";
 				VERSION_INFO_PREFIX = "";
@@ -571,6 +568,7 @@
 				MTL_ENABLE_DEBUG_INFO = NO;
 				SDKROOT = iphoneos;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
+				SWIFT_VERSION = 3.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 				VALIDATE_PRODUCT = YES;
 				VERSIONING_SYSTEM = "apple-generic";
@@ -595,7 +593,6 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
-				SWIFT_VERSION = 2.3;
 			};
 			name = Debug;
 		};
@@ -615,7 +612,6 @@
 				PRODUCT_BUNDLE_IDENTIFIER = com.ashfurrow.Action;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SKIP_INSTALL = YES;
-				SWIFT_VERSION = 2.3;
 			};
 			name = Release;
 		};

AlertAction.swift

@@ -4,7 +4,7 @@ import RxCocoa
 
 public extension UIAlertAction {
 
-    public static func Action(title: String?, style: UIAlertActionStyle) -> UIAlertAction {
+    public static func Action(_ title: String?, style: UIAlertActionStyle) -> UIAlertAction {
         return UIAlertAction(title: title, style: style, handler: { action in
             action.rx_action?.execute()
         })
@@ -48,17 +48,17 @@ extension UIAlertAction {
             MainScheduler.ensureExecutingOnScheduler()
 
             switch event {
-            case .Next(let value):
-                self?.enabled = value
-            case .Error(let error):
+            case .next(let value):
+                self?.isEnabled = value
+            case .error(let error):
                 let error = "Binding error to UI: \(error)"
                 #if DEBUG
                     rxFatalError(error)
                 #else
                     print(error)
                 #endif
                 break
-            case .Completed:
+            case .completed:
                 break
             }
         }

Cartfile

@@ -1 +1 @@
-github "ReactiveX/RxSwift" ~> 2.0
+github "ReactiveX/RxSwift" "3.0.0-beta.1"

Cartfile.private

@@ -1,2 +1,2 @@
-github "Quick/Quick" ~> 0.9.3
-github "Quick/Nimble" ~> 4.1.0
+github "Quick/Quick" "swift-3.0"
+github "Quick/Nimble" "master"

Cartfile.resolved

@@ -1,3 +1,3 @@
-github "Quick/Nimble" "v4.1.0"
-github "Quick/Quick" "v0.9.3"
-github "ReactiveX/RxSwift" "2.6.0"
+github "Quick/Nimble" "db706fc1d7130f6ac96c56aaf0e635fa3217fe57"
+github "Quick/Quick" "1503fb019d72417d5d6e4fbebdbaa03c9e4a125f"
+github "ReactiveX/RxSwift" "3.0.0-beta.1"

Carthage/Checkouts/Nimble

@@ -14,30 +14,30 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
     var window: UIWindow?
 
 
-    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
         // Override point for customization after application launch.
         return true
     }
 
-    func applicationWillResignActive(application: UIApplication) {
+    func applicationWillResignActive(_ application: UIApplication) {
         // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
         // Use this method to pause ongoing tasks, disable timers, and throttle down OpenGL ES frame rates. Games should use this method to pause the game.
     }
 
-    func applicationDidEnterBackground(application: UIApplication) {
+    func applicationDidEnterBackground(_ application: UIApplication) {
         // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
         // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
     }
 
-    func applicationWillEnterForeground(application: UIApplication) {
+    func applicationWillEnterForeground(_ application: UIApplication) {
         // Called as part of the transition from the background to the inactive state; here you can undo many of the changes made on entering the background.
     }
 
-    func applicationDidBecomeActive(application: UIApplication) {
+    func applicationDidBecomeActive(_ application: UIApplication) {
         // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
     }
 
-    func applicationWillTerminate(application: UIApplication) {
+    func applicationWillTerminate(_ application: UIApplication) {
         // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
     }