Merge pull request #164 from ReactiveCocoa/inner-disposable

Rename `innerDisposable` to `inner`.

Author: mdiep

Sources/Deprecations+Removals.swift

@@ -52,6 +52,19 @@ extension Disposable {
 	public var disposed: Bool { fatalError() }
 }
 
+extension SerialDisposable {
+	@available(*, unavailable, renamed:"inner")
+	public var innerDisposable: Disposable? {
+		get { fatalError() }
+		set { fatalError() }
+ }
+}
+
+extension ScopedDisposable {
+	@available(*, unavailable, renamed:"inner")
+	public var innerDisposable: Disposable { fatalError() }
+}
+
 extension ActionProtocol {
 	@available(*, unavailable, renamed:"isEnabled")
 	public var enabled: Bool { fatalError() }

Sources/Disposable.swift

@@ -240,66 +240,67 @@ public final class CompositeDisposable: Disposable {
 }
 
 /// A disposable that, upon deinitialization, will automatically dispose of
-/// another disposable.
-public final class ScopedDisposable<InnerDisposable: Disposable>: Disposable {
+/// its inner disposable.
+public final class ScopedDisposable<Inner: Disposable>: Disposable {
 	/// The disposable which will be disposed when the ScopedDisposable
 	/// deinitializes.
-	public let innerDisposable: InnerDisposable
+	public let inner: Inner
 
 	public var isDisposed: Bool {
-		return innerDisposable.isDisposed
+		return inner.isDisposed
 	}
 
 	/// Initialize the receiver to dispose of the argument upon
 	/// deinitialization.
 	///
 	/// - parameters:
 	///   - disposable: A disposable to dispose of when deinitializing.
-	public init(_ disposable: InnerDisposable) {
-		innerDisposable = disposable
+	public init(_ disposable: Inner) {
+		inner = disposable
 	}
 
 	deinit {
 		dispose()
 	}
 
 	public func dispose() {
-		return innerDisposable.dispose()
+		return inner.dispose()
 	}
 }
 
-extension ScopedDisposable where InnerDisposable: AnyDisposable {
+extension ScopedDisposable where Inner: AnyDisposable {
 	/// Initialize the receiver to dispose of the argument upon
 	/// deinitialization.
 	///
 	/// - parameters:
 	///   - disposable: A disposable to dispose of when deinitializing, which
 	///                 will be wrapped in an `AnyDisposable`.
 	public convenience init(_ disposable: Disposable) {
-		self.init(InnerDisposable(disposable))
+		self.init(Inner(disposable))
 	}
 }
 
-/// A disposable that will optionally dispose of another disposable.
+/// A disposable that disposes of its wrapped disposable, and allows its
+/// wrapped disposable to be replaced.
 public final class SerialDisposable: Disposable {
-	private let _innerDisposable: Atomic<Disposable?>
+	private let _inner: Atomic<Disposable?>
 	private var state: UnsafeAtomicState<DisposableState>
 
 	public var isDisposed: Bool {
 		return state.is(.disposed)
 	}
 
-	/// The inner disposable to dispose of.
+	/// The current inner disposable to dispose of.
 	///
 	/// Whenever this property is set (even to the same value!), the previous
 	/// disposable is automatically disposed.
-	public var innerDisposable: Disposable? {
+	public var inner: Disposable? {
 		get {
-			return _innerDisposable.value
+			return _inner.value
 		}
 
 		set(d) {
-			_innerDisposable.swap(d)?.dispose()
+			_inner.swap(d)?.dispose()
 			if let d = d, isDisposed {
 				d.dispose()
 			}
@@ -312,13 +313,13 @@ public final class SerialDisposable: Disposable {
 	/// - parameters:
 	///   - disposable: Optional disposable.
 	public init(_ disposable: Disposable? = nil) {
-		self._innerDisposable = Atomic(disposable)
+		self._inner = Atomic(disposable)
 		self.state = UnsafeAtomicState(DisposableState.active)
 	}
 
 	public func dispose() {
 		if state.tryDispose() {
-			_innerDisposable.swap(nil)?.dispose()
+			_inner.swap(nil)?.dispose()
 		}
 	}
 
@@ -381,7 +382,7 @@ public func +=(lhs: CompositeDisposable, rhs: @escaping () -> ()) -> CompositeDi
 ///            remove the disposable later (if desired).
 @discardableResult
 public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) -> CompositeDisposable.DisposableHandle {
-	return lhs.innerDisposable.add(rhs)
+	return lhs.inner.add(rhs)
 }
 
 /// Adds the right-hand-side disposable to the left-hand-side
@@ -399,5 +400,5 @@ public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: Disposable?) ->
 ///            remove the disposable later (if desired).
 @discardableResult
 public func +=(lhs: ScopedDisposable<CompositeDisposable>, rhs: @escaping () -> ()) -> CompositeDisposable.DisposableHandle {
-	return lhs.innerDisposable.add(rhs)
+	return lhs.inner.add(rhs)
 }

Sources/Flatten.swift

@@ -646,7 +646,7 @@ extension SignalProtocol where Value: SignalProducerProtocol, Error == Value.Err
 						$0.replacingInnerSignal = true
 					}
 
-					latestInnerDisposable.innerDisposable = innerDisposable
+					latestInnerDisposable.inner = innerDisposable
 
 					state.modify {
 						$0.replacingInnerSignal = false
@@ -929,7 +929,7 @@ extension SignalProtocol {
 				observer.send(value: value)
 			case let .failed(error):
 				handler(error).startWithSignal { signal, disposable in
-					serialDisposable.innerDisposable = disposable
+					serialDisposable.inner = disposable
 					signal.observe(observer)
 				}
 			case .completed:
@@ -950,7 +950,7 @@ extension SignalProducerProtocol {
 			disposable += serialDisposable
 
 			self.startWithSignal { signal, signalDisposable in
-				serialDisposable.innerDisposable = signalDisposable
+				serialDisposable.inner = signalDisposable
 
 				_ = signal.observeFlatMapError(handler, observer, serialDisposable)
 			}

Sources/Scheduler.swift

@@ -417,7 +417,7 @@ public final class TestScheduler: DateSchedulerProtocol {
 	private func schedule(after date: Date, interval: DispatchTimeInterval, disposable: SerialDisposable, action: @escaping () -> Void) {
 		precondition(interval.timeInterval >= 0)
 
-		disposable.innerDisposable = schedule(after: date) { [unowned self] in
+		disposable.inner = schedule(after: date) { [unowned self] in
 			action()
 			self.schedule(after: date.addingTimeInterval(interval), interval: interval, disposable: disposable, action: action)
 		}

Sources/Signal.swift

@@ -1305,10 +1305,10 @@ extension SignalProtocol {
 		return Signal { observer in
 			let disposable = SerialDisposable()
 
-			disposable.innerDisposable = trigger.observe { event in
+			disposable.inner = trigger.observe { event in
 				switch event {
 				case .value, .completed:
-					disposable.innerDisposable = self.observe(observer)
+					disposable.inner = self.observe(observer)
 
 				case .failed, .interrupted:
 					break
@@ -1684,7 +1684,7 @@ extension SignalProtocol {
 
 			disposable += self.observe { event in
 				guard let value = event.value else {
-					schedulerDisposable.innerDisposable = scheduler.schedule {
+					schedulerDisposable.inner = scheduler.schedule {
 						observer.action(event)
 					}
 					return
@@ -1711,7 +1711,7 @@ extension SignalProtocol {
 					}
 				}
 
-				schedulerDisposable.innerDisposable = scheduler.schedule(after: scheduleDate) {
+				schedulerDisposable.inner = scheduler.schedule(after: scheduleDate) {
 					let pendingValue: Value? = state.modify { state in
 						defer {
 							if state.pendingValue != nil {
@@ -1785,7 +1785,7 @@ extension SignalProtocol {
 					}
 
 					if let value = valueToSend {
-						schedulerDisposable.innerDisposable = scheduler.schedule {
+						schedulerDisposable.inner = scheduler.schedule {
 							observer.send(value: value)
 						}
 					}
@@ -1812,7 +1812,7 @@ extension SignalProtocol {
 				}
 
 				if let event = eventToSend {
-					schedulerDisposable.innerDisposable = scheduler.schedule {
+					schedulerDisposable.inner = scheduler.schedule {
 						observer.action(event)
 					}
 				}

Sources/SignalProducer.swift

@@ -1631,7 +1631,7 @@ extension SignalProducerProtocol {
 
 			func iterate(_ current: Int) {
 				self.startWithSignal { signal, signalDisposable in
-					serialDisposable.innerDisposable = signalDisposable
+					serialDisposable.inner = signalDisposable
 
 					signal.observe { event in
 						if case .completed = event {

Tests/ReactiveSwiftTests/DisposableSpec.swift

@@ -115,14 +115,14 @@ class DisposableSpec: QuickSpec {
 
 			it("should dispose of the inner disposable") {
 				let simpleDisposable = SimpleDisposable()
-				disposable.innerDisposable = simpleDisposable
+				disposable.inner = simpleDisposable
 
-				expect(disposable.innerDisposable).notTo(beNil())
+				expect(disposable.inner).notTo(beNil())
 				expect(simpleDisposable.isDisposed) == false
 				expect(disposable.isDisposed) == false
 
 				disposable.dispose()
-				expect(disposable.innerDisposable).to(beNil())
+				expect(disposable.inner).to(beNil())
 				expect(simpleDisposable.isDisposed) == true
 				expect(disposable.isDisposed) == true
 			}
@@ -131,16 +131,16 @@ class DisposableSpec: QuickSpec {
 				let oldDisposable = SimpleDisposable()
 				let newDisposable = SimpleDisposable()
 
-				disposable.innerDisposable = oldDisposable
+				disposable.inner = oldDisposable
 				expect(oldDisposable.isDisposed) == false
 				expect(newDisposable.isDisposed) == false
 
-				disposable.innerDisposable = newDisposable
+				disposable.inner = newDisposable
 				expect(oldDisposable.isDisposed) == true
 				expect(newDisposable.isDisposed) == false
 				expect(disposable.isDisposed) == false
 
-				disposable.innerDisposable = nil
+				disposable.inner = nil
 				expect(newDisposable.isDisposed) == true
 				expect(disposable.isDisposed) == false
 			}

Tests/ReactiveSwiftTests/SchedulerSpec.swift

@@ -203,7 +203,7 @@ class SchedulerSpec: QuickSpec {
 					var count = 0
 					let timesToRun = 3
 
-					disposable.innerDisposable = scheduler.schedule(after: Date(), interval: .milliseconds(10), leeway: .seconds(0)) {
+					disposable.inner = scheduler.schedule(after: Date(), interval: .milliseconds(10), leeway: .seconds(0)) {
 						expect(Thread.isMainThread) == false
 
 						count += 1