Merge pull request #25 from erwald/tuple-bridging

Tuple bridging

Author: erichoracek

Cartfile

@@ -1,2 +1,2 @@
-github "ReactiveCocoa/ReactiveObjC" ~> 2.1.2
+github "ReactiveCocoa/ReactiveObjC" ~> 3.0.0
 github "ReactiveCocoa/ReactiveSwift" ~> 1.1

Cartfile.resolved

@@ -1,6 +1,6 @@
 github "Quick/Nimble" "8116a83864ee78339798c3ef425c42f6ca6bf034"
 github "Quick/Quick" "v1.1.0"
-github "ReactiveCocoa/ReactiveObjC" "2.1.2"
-github "ReactiveCocoa/ReactiveSwift" "1.1.1"
+github "ReactiveCocoa/ReactiveObjC" "3.0.0"
 github "antitypical/Result" "3.2.1"
 github "jspahrsummers/xcconfigs" "3d9d99634cae6d586e272543d527681283b33eb0"
+github "ReactiveCocoa/ReactiveSwift" "1.1.2"

Carthage/Checkouts/ReactiveObjC

@@ -4,7 +4,7 @@ Pod::Spec.new do |s|
   s.summary      = "Bridge between ReactiveObjC and ReactiveSwift"
   s.description  = <<-DESC
                    After announced Swift, ReactiveCocoa was rewritten in Swift. This framework creates a bridge between those Swift and Objective-C APIs (ReactiveSwift and ReactiveObjC).
-                   
+
                    Because the APIs are based on fundamentally different designs, the conversion is not always one-to-one; however, every attempt has been made to faithfully translate the concepts between the two APIs (and languages).
                    DESC
   s.homepage     = "https://github.com/ReactiveCocoa/ReactiveObjCBridge"
@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://github.com/ReactiveCocoa/ReactiveObjCBridge.git", :tag => "#{s.version}" }
   s.source_files = "ReactiveObjCBridge/*.{swift}"
 
-  s.dependency 'ReactiveObjC', '~> 2.1.2'
+  s.dependency 'ReactiveObjC', '~> 3.0.0'
   s.dependency 'ReactiveSwift', '~> 1.1'
 
   s.pod_target_xcconfig = { "OTHER_SWIFT_FLAGS[config=Release]" => "-suppress-warnings" }

Carthage/Checkouts/ReactiveSwift

@@ -120,6 +120,10 @@ private func defaultNSError(_ message: String, file: String, line: Int) -> NSErr
 ///
 /// - returns: Signal producer created from the provided signal.
 public func bridgedSignalProducer<Value>(from signal: RACSignal<Value>, file: String = #file, line: Int = #line) -> SignalProducer<Value?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line)
+}
+
+private func _bridgedSignalProducer<Value>(from signal: RACSignal<Value>, file: String = #file, line: Int = #line) -> SignalProducer<Value?, AnyError> {
 	return SignalProducer<Value?, AnyError> { observer, disposable in
 		let next: (_ value: Value?) -> Void = { obj in
 			observer.send(value: obj)
@@ -137,6 +141,71 @@ public func bridgedSignalProducer<Value>(from signal: RACSignal<Value>, file: St
 	}
 }
 
+/// Create a `SignalProducer` of 1-tuples which will subscribe to the provided
+/// signal once for each invocation of `start()`.
+///
+/// - parameters:
+///   - signal: The signal of `RACOneTuple` objects to bridge to a signal producer of 1-tuples.
+///   - file: Current file name.
+///   - line: Current line in file.
+///
+/// - returns: Signal producer created from the provided signal.
+public func bridgedSignalProducer<First>(from signal: RACSignal<RACOneTuple<First>>, file: String = #file, line: Int = #line) -> SignalProducer<(First?)?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line).map { $0.map(bridgedTuple) }
+}
+
+/// Create a `SignalProducer` of 2-tuples which will subscribe to the provided
+/// signal once for each invocation of `start()`.
+///
+/// - parameters:
+///   - signal: The signal of `RACTwoTuple` objects to bridge to a signal producer of 2-tuples.
+///   - file: Current file name.
+///   - line: Current line in file.
+///
+/// - returns: Signal producer created from the provided signal.
+public func bridgedSignalProducer<First, Second>(from signal: RACSignal<RACTwoTuple<First, Second>>, file: String = #file, line: Int = #line) -> SignalProducer<(First?, Second?)?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line).map { $0.map(bridgedTuple) }
+}
+
+/// Create a `SignalProducer` of 3-tuples which will subscribe to the provided
+/// signal once for each invocation of `start()`.
+///
+/// - parameters:
+///   - signal: The signal of `RACThreeTuple` objects to bridge to a signal producer of 3-tuples.
+///   - file: Current file name.
+///   - line: Current line in file.
+///
+/// - returns: Signal producer created from the provided signal.
+public func bridgedSignalProducer<First, Second, Third>(from signal: RACSignal<RACThreeTuple<First, Second, Third>>, file: String = #file, line: Int = #line) -> SignalProducer<(First?, Second?, Third?)?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line).map { $0.map(bridgedTuple) }
+}
+
+/// Create a `SignalProducer` of 4-tuples which will subscribe to the provided
+/// signal once for each invocation of `start()`.
+///
+/// - parameters:
+///   - signal: The signal of `RACFourTuple` objects to bridge to a signal producer of 4-tuples.
+///   - file: Current file name.
+///   - line: Current line in file.
+///
+/// - returns: Signal producer created from the provided signal.
+public func bridgedSignalProducer<First, Second, Third, Fourth>(from signal: RACSignal<RACFourTuple<First, Second, Third, Fourth>>, file: String = #file, line: Int = #line) -> SignalProducer<(First?, Second?, Third?, Fourth?)?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line).map { $0.map(bridgedTuple) }
+}
+
+/// Create a `SignalProducer` of 5-tuples which will subscribe to the provided
+/// signal once for each invocation of `start()`.
+///
+/// - parameters:
+///   - signal: The signal of `RACFiveTuple` objects to bridge to a signal producer of 5-tuples.
+///   - file: Current file name.
+///   - line: Current line in file.
+///
+/// - returns: Signal producer created from the provided signal.
+public func bridgedSignalProducer<First, Second, Third, Fourth, Fifth>(from signal: RACSignal<RACFiveTuple<First, Second, Third, Fourth, Fifth>>, file: String = #file, line: Int = #line) -> SignalProducer<(First?, Second?, Third?, Fourth?, Fifth?)?, AnyError> {
+	return _bridgedSignalProducer(from: signal, file: file, line: line).map { $0.map(bridgedTuple) }
+}
+
 extension SignalProducerProtocol where Value: AnyObject {
 	/// Create a `RACSignal` that will `start()` the producer once for each
 	/// subscription.
@@ -275,6 +344,7 @@ extension ActionProtocol {
 ///         is.
 ///
 /// - parameters:
+///   - command: The command to bridge to an action.
 ///   - file: Current file name.
 ///   - line: Current line in file.
 ///
@@ -360,6 +430,58 @@ extension ActionProtocol where Input: OptionalProtocol, Input.Wrapped: AnyObject
 	}
 }
 
+// MARK: Tuples
+
+/// Creates a Swift tuple with one element.
+///
+/// - parameters:
+///   - tuple: The `RACOneTuple` to bridge to a Swift tuple.
+///
+/// - returns: Swift tuple created from the provided `RACOneTuple` object.
+public func bridgedTuple<First>(from tuple: RACOneTuple<First>) -> (First?) {
+	return (tuple.first)
+}
+
+/// Creates a Swift tuple with two elements.
+///
+/// - parameters:
+///   - tuple: The `RACTwoTuple` to bridge to a Swift tuple.
+///
+/// - returns: Swift tuple created from the provided `RACTwoTuple` object.
+public func bridgedTuple<First, Second>(from tuple: RACTwoTuple<First, Second>) -> (First?, Second?) {
+	return (tuple.first, tuple.second)
+}
+
+/// Creates a Swift tuple with three elements.
+///
+/// - parameters:
+///   - tuple: The `RACThreeTuple` to bridge to a Swift tuple.
+///
+/// - returns: Swift tuple created from the provided `RACThreeTuple` object.
+public func bridgedTuple<First, Second, Third>(from tuple: RACThreeTuple<First, Second, Third>) -> (First?, Second?, Third?) {
+	return (tuple.first, tuple.second, tuple.third)
+}
+
+/// Creates a Swift tuple with four elements.
+///
+/// - parameters:
+///   - tuple: The `RACFourTuple` to bridge to a Swift tuple.
+///
+/// - returns: Swift tuple created from the provided `RACFourTuple` object.
+public func bridgedTuple<First, Second, Third, Fourth>(from tuple: RACFourTuple<First, Second, Third, Fourth>) -> (First?, Second?, Third?, Fourth?) {
+	return (tuple.first, tuple.second, tuple.third, tuple.fourth)
+}
+
+/// Creates a Swift tuple with five elements.
+///
+/// - parameters:
+///   - tuple: The `RACFiveTuple` to bridge to a Swift tuple.
+///
+/// - returns: Swift tuple created from the provided `RACFiveTuple` object.
+public func bridgedTuple<First, Second, Third, Fourth, Fifth>(from tuple: RACFiveTuple<First, Second, Third, Fourth, Fifth>) -> (First?, Second?, Third?, Fourth?, Fifth?) {
+	return (tuple.first, tuple.second, tuple.third, tuple.fourth, tuple.fifth)
+}
+
 // MARK: - Helpers
 
 extension DispatchTimeInterval {

ReactiveObjCBridge.podspec

@@ -211,7 +211,7 @@ class ObjectiveCBridgingSpec: QuickSpec {
 			var command: RACCommand<NSNumber, NSNumber>!
 			var results: [Int] = []
 
-			var enabledSubject: RACSubject!
+			var enabledSubject: RACSubject<NSNumber>!
 			var enabled = false
 
 			var action: Action<NSNumber?, NSNumber?, AnyError>!
@@ -220,9 +220,9 @@ class ObjectiveCBridgingSpec: QuickSpec {
 				enabledSubject = RACSubject()
 				results = []
 
-				let enabledSignal = RACSignal<NSNumber>.createSignal({ subscriber in
+				let enabledSignal = RACSignal<NSNumber>.createSignal { subscriber in
 					return enabledSubject.subscribe(subscriber)
-				})
+				}
 
 				command = RACCommand<NSNumber, NSNumber>(enabled: enabledSignal) { input in
 					let inputNumber = input as! Int + 1
@@ -369,12 +369,12 @@ class ObjectiveCBridgingSpec: QuickSpec {
 				var action: Action<Optional<AnyObject>, NSString, TestError>!
 				var command: RACCommand<AnyObject, NSString>!
 
-				let inputSubject = RACSubject()
+				let inputSubject = RACSubject<AnyObject>()
 
 				let inputSignal = RACSignal<NSNumber>
-					.createSignal({ subscriber in
+					.createSignal { subscriber in
 						return inputSubject.subscribe(subscriber)
-					})
+					}
 					.replay()
 					.materialize()
 
@@ -406,5 +406,149 @@ class ObjectiveCBridgingSpec: QuickSpec {
 				expect(value).to(beNil())
 			}
 		}
+
+		context("re tuples") {
+			describe("bridgedTuple") {
+				it("should bridge 1-tuples") {
+					let racTuple = RACOneTuple<NSNumber>.pack(0)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(tuple) == (0)
+				}
+
+				it("should bridge 2-tuples") {
+					let racTuple = RACTwoTuple<NSNumber, NSNumber>.pack(0, 1)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 2
+					expect(tuple.0) == 0
+					expect(tuple.1) == 1
+				}
+
+				it("should bridge 3-tuples") {
+					let racTuple = RACThreeTuple<NSNumber, NSNumber, NSNumber>.pack(0, 1, 2)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 3
+					expect(tuple.0) == 0
+					expect(tuple.1) == 1
+					expect(tuple.2) == 2
+				}
+
+				it("should bridge 4-tuples") {
+					let racTuple = RACFourTuple<NSNumber, NSNumber, NSNumber, NSNumber>.pack(0, 1, 2, 3)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 4
+					expect(tuple.0) == 0
+					expect(tuple.1) == 1
+					expect(tuple.2) == 2
+					expect(tuple.3) == 3
+				}
+
+				it("should bridge 5-tuples") {
+					let racTuple = RACFiveTuple<NSNumber, NSNumber, NSNumber, NSNumber, NSNumber>.pack(0, 1, 2, 3, 4)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 5
+					expect(tuple.0) == 0
+					expect(tuple.1) == 1
+					expect(tuple.2) == 2
+					expect(tuple.3) == 3
+					expect(tuple.4) == 4
+				}
+
+				it("should bridge tuples containing nils") {
+					let racTuple = RACThreeTuple<NSString, NSString, NSString>.pack(nil, nil, nil)
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 3
+					expect(tuple.0).to(beNil())
+					expect(tuple.1).to(beNil())
+					expect(tuple.2).to(beNil())
+				}
+
+				it("should bridge tuples containing both nils and values") {
+					let racTuple = RACThreeTuple<NSString, NSString, NSString>.pack("rose", nil, "petal")
+					let tuple = bridgedTuple(from: racTuple)
+
+					expect(Mirror(reflecting: tuple).children.count) == 3
+					expect(tuple.0) == "rose"
+					expect(tuple.1).to(beNil())
+					expect(tuple.2) == "petal"
+				}
+			}
+
+			describe("bridgedSignalProducer") {
+				it("should bridge signals of 1-tuples") {
+					let racSignal = RACSignal<RACOneTuple<NSNumber>>.return(RACOneTuple<NSNumber>.pack(0))
+					let producer = bridgedSignalProducer(from: racSignal)
+
+					let value = producer.single()?.value as? (Int) ?? nil
+					expect(value) == (0)
+				}
+
+				it("should bridge signals of 2-tuples") {
+					let racSignal = RACSignal<RACTwoTuple<NSNumber, NSNumber>>.return(RACTwoTuple<NSNumber, NSNumber>.pack(0, 1))
+					let producer = bridgedSignalProducer(from: racSignal)
+
+					let value = producer.single()?.value ?? nil
+					let valueMirror = value.map { Mirror(reflecting: $0) }
+					expect(valueMirror?.children.count) == 2
+					expect(value?.0) == 0
+					expect(value?.1) == 1
+				}
+
+				it("should bridge signals of 3-tuples") {
+					let racSignal = RACSignal<RACThreeTuple<NSNumber, NSNumber, NSNumber>>.return(RACThreeTuple<NSNumber, NSNumber, NSNumber>.pack(0, 1, 2))
+					let producer = bridgedSignalProducer(from: racSignal).skipNil()
+
+					let value = producer.single()?.value ?? nil
+					let valueMirror = value.map { Mirror(reflecting: $0) }
+					expect(valueMirror?.children.count) == 3
+					expect(value?.0) == 0
+					expect(value?.1) == 1
+					expect(value?.2) == 2
+				}
+
+				it("should bridge signals of 4-tuples") {
+					let racSignal = RACSignal<RACFourTuple<NSNumber, NSNumber, NSNumber, NSNumber>>.return(RACFourTuple<NSNumber, NSNumber, NSNumber, NSNumber>.pack(0, 1, 2, 3))
+					let producer = bridgedSignalProducer(from: racSignal).skipNil()
+
+					let value = producer.single()?.value ?? nil
+					let valueMirror = value.map { Mirror(reflecting: $0) }
+					expect(valueMirror?.children.count) == 4
+					expect(value?.0) == 0
+					expect(value?.1) == 1
+					expect(value?.2) == 2
+					expect(value?.3) == 3
+				}
+
+				it("should bridge signals of 5-tuples") {
+					let racSignal = RACSignal<RACFiveTuple<NSNumber, NSNumber, NSNumber, NSNumber, NSNumber>>.return(RACFiveTuple<NSNumber, NSNumber, NSNumber, NSNumber, NSNumber>.pack(0, 1, 2, 3, 4))
+					let producer = bridgedSignalProducer(from: racSignal).skipNil()
+
+					let value = producer.single()?.value ?? nil
+					let valueMirror = value.map { Mirror(reflecting: $0) }
+					expect(valueMirror?.children.count) == 5
+					expect(value?.0) == 0
+					expect(value?.1) == 1
+					expect(value?.2) == 2
+					expect(value?.3) == 3
+					expect(value?.4) == 4
+				}
+
+				it("should bridge signals of unnumbered tuples") {
+					let racSignal = RACSignal<RACTuple>.return(RACTuple(objectsFrom: [0, 1]))
+					let producer = bridgedSignalProducer(from: racSignal).skipNil()
+
+					let value = producer.single()?.value
+					expect(value?.count) == 2
+					expect(value?.first as? Int) == 0
+					expect(value?.second as? Int) == 1
+					expect(value?.third).to(beNil())
+				}
+			}
+		}
 	}
 }