Renames Completeable to Completable. #1134

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 
 ## [3.3.0](https://github.com/ReactiveX/RxSwift/releases/tag/3.3.0) (Xcode 8 / Swift 3.0 compatible)
 
-* Adds `Single`, `Maybe`, `Completeable` units inspired by RxJava (operators):
+* Adds `Single`, `Maybe`, `Completable` units inspired by RxJava (operators):
  * `create`
  * `deferred`
  * `just`
@@ -25,7 +25,7 @@ All notable changes to this project will be documented in this file.
  * `zip`
 * Adds `asSingle()` operator on `ObservableType`.
 * Adds `asMaybe()` operator on `ObservableType`.
-* Adds `asCompleteable()` operator on `ObservableType`.
+* Adds `asCompletable()` operator on `ObservableType`.
 * Adds variadic `combineLatest` and `zip` overloads without result selector (defaults to tuple).
 * Adds array `combineLatest` and `zip` overloads with result selector (defaults to array of elements)
 * Adds optimized synchronous `merge` operator to observable sequence (variadic, array, collection). #579

Documentation/Units.md

@@ -171,7 +171,7 @@ Sharing side effects = share* (one of the `share` operators)
 
 * Contains exactly zero or one elements
 
-### Completeable
+### Completable
 
 * Contains zero elements
 

RxSwift/Units/PrimitiveSequence.swift

@@ -26,9 +26,9 @@ public enum MaybeTrait { }
 public typealias Maybe<Element> = PrimitiveSequence<MaybeTrait, Element>
 
 /// Sequence containing 0 elements
-public enum CompleteableTrait { }
+public enum CompletableTrait { }
 /// Represents a push style sequence containing 0 elements.
-public typealias Completeable = PrimitiveSequence<CompleteableTrait, Swift.Never>
+public typealias Completable = PrimitiveSequence<CompletableTrait, Swift.Never>
 
 /// Observable sequences containing 0 or 1 element
 public protocol PrimitiveSequenceType {
@@ -199,18 +199,18 @@ public extension PrimitiveSequenceType where TraitType == MaybeTrait {
 
 // </Maybe>
 
-// <Completeable>
+// <Completable>
 
-public enum CompleteableEvent {
+public enum CompletableEvent {
  /// Sequence terminated with an error. (underlying observable sequence emits: `.error(Error)`)
  case error(Swift.Error)
 
  /// Sequence completed successfully.
  case completed
 }
 
-public extension PrimitiveSequenceType where TraitType == CompleteableTrait, ElementType == Swift.Never {
- public typealias CompleteableObserver = (CompleteableEvent) -> ()
+public extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Swift.Never {
+ public typealias CompletableObserver = (CompletableEvent) -> ()
 
  /**
  Creates an observable sequence from a specified subscribe method implementation.
@@ -220,7 +220,7 @@ public extension PrimitiveSequenceType where TraitType == CompleteableTrait, Ele
  - parameter subscribe: Implementation of the resulting observable sequence's `subscribe` method.
  - returns: The observable sequence with the specified implementation for the `subscribe` method.
  */
- public static func create(subscribe: @escaping (@escaping CompleteableObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
+ public static func create(subscribe: @escaping (@escaping CompletableObserver) -> Disposable) -> PrimitiveSequence<TraitType, ElementType> {
  let source = Observable<ElementType>.create { observer in
  return subscribe { event in
  switch event {
@@ -240,7 +240,7 @@ public extension PrimitiveSequenceType where TraitType == CompleteableTrait, Ele
 
  - returns: Subscription for `observer` that can be used to cancel production of sequence elements and free resources.
  */
- public func subscribe(_ observer: @escaping (CompleteableEvent) -> ()) -> Disposable {
+ public func subscribe(_ observer: @escaping (CompletableEvent) -> ()) -> Disposable {
  var stopped = false
  return self.primitiveSequence.asObservable().subscribe { event in
  if stopped { return }
@@ -258,7 +258,7 @@ public extension PrimitiveSequenceType where TraitType == CompleteableTrait, Ele
  }
 }
 
-// </Completeable>
+// </Completable>
 
 extension PrimitiveSequence {
  /**
@@ -540,15 +540,15 @@ extension PrimitiveSequenceType where TraitType == MaybeTrait {
  }
 }
 
-extension PrimitiveSequenceType where TraitType == CompleteableTrait, ElementType == Never {
+extension PrimitiveSequenceType where TraitType == CompletableTrait, ElementType == Never {
  /**
  Returns an empty observable sequence, using the specified scheduler to send out the single `Completed` message.
 
  - seealso: [empty operator on reactivex.io](http://reactivex.io/documentation/operators/empty-never-throw.html)
 
  - returns: An observable sequence with no elements.
  */
- public static func empty() -> PrimitiveSequence<CompleteableTrait, Never> {
+ public static func empty() -> PrimitiveSequence<CompletableTrait, Never> {
  return PrimitiveSequence(raw: Observable.empty())
  }
 }
@@ -583,8 +583,8 @@ extension ObservableType where E == Never {
  /**
  - returns: An observable sequence that completes.
  */
- public func asCompleteable()
- -> Completeable {
+ public func asCompletable()
+ -> Completable {
  return PrimitiveSequence(raw: self.asObservable())
  }
 }

RxTest/Event+Equatable.swift

@@ -81,7 +81,7 @@ public func == <Element: Equatable>(lhs: MaybeEvent<Element>, rhs: MaybeEvent<El
 ///
 /// In case `Error` events are being compared, they are equal in case their `NSError` representations are equal (domain and code)
 /// and their string representations are equal.
-public func == (lhs: CompleteableEvent, rhs: CompleteableEvent) -> Bool {
+public func == (lhs: CompletableEvent, rhs: CompletableEvent) -> Bool {
  switch (lhs, rhs) {
  case (.completed, .completed): return true
  case (.error(let e1), .error(let e2)):

RxTest/XCTest+Rx.swift

@@ -135,7 +135,7 @@ public func XCTAssertEqual<T: Equatable>(_ lhs: [MaybeEvent<T>], _ rhs: [MaybeEv
  - parameter lhs: first set of events.
  - parameter lhs: second set of events.
  */
-public func XCTAssertEqual(_ lhs: [CompleteableEvent], _ rhs: [CompleteableEvent], file: StaticString = #file, line: UInt = #line) {
+public func XCTAssertEqual(_ lhs: [CompletableEvent], _ rhs: [CompletableEvent], file: StaticString = #file, line: UInt = #line) {
  let leftEquatable = lhs.map { AnyEquatable(target: $0, comparer: ==) }
  let rightEquatable = rhs.map { AnyEquatable(target: $0, comparer: ==) }
  #if os(Linux)

Sources/AllTestz/main.swift

@@ -88,11 +88,11 @@ final class PrimitiveSequenceTest_ : PrimitiveSequenceTest, RxTestCase {
  ("testMaybe_create_completed", PrimitiveSequenceTest.testMaybe_create_completed),
  ("testMaybe_create_error", PrimitiveSequenceTest.testMaybe_create_error),
  ("testMaybe_create_disposing", PrimitiveSequenceTest.testMaybe_create_disposing),
- ("testCompleteable_Subscription_completed", PrimitiveSequenceTest.testCompleteable_Subscription_completed),
- ("testCompleteable_Subscription_error", PrimitiveSequenceTest.testCompleteable_Subscription_error),
- ("testCompleteable_create_completed", PrimitiveSequenceTest.testCompleteable_create_completed),
- ("testCompleteable_create_error", PrimitiveSequenceTest.testCompleteable_create_error),
- ("testCompleteable_create_disposing", PrimitiveSequenceTest.testCompleteable_create_disposing),
+ ("testCompletable_Subscription_completed", PrimitiveSequenceTest.testCompletable_Subscription_completed),
+ ("testCompletable_Subscription_error", PrimitiveSequenceTest.testCompletable_Subscription_error),
+ ("testCompletable_create_completed", PrimitiveSequenceTest.testCompletable_create_completed),
+ ("testCompletable_create_error", PrimitiveSequenceTest.testCompletable_create_error),
+ ("testCompletable_create_disposing", PrimitiveSequenceTest.testCompletable_create_disposing),
  ("testSingle_deferred_producesSingleElement", PrimitiveSequenceTest.testSingle_deferred_producesSingleElement),
  ("testSingle_just_producesSingleElement", PrimitiveSequenceTest.testSingle_just_producesSingleElement),
  ("testSingle_just2_producesSingleElement", PrimitiveSequenceTest.testSingle_just2_producesSingleElement),
@@ -121,8 +121,8 @@ final class PrimitiveSequenceTest_ : PrimitiveSequenceTest, RxTestCase {
  ("testAsMaybe_Many", PrimitiveSequenceTest.testAsMaybe_Many),
  ("testAsMaybe_Error", PrimitiveSequenceTest.testAsMaybe_Error),
  ("testAsMaybe_Error2", PrimitiveSequenceTest.testAsMaybe_Error2),
- ("testAsCompleteable_Empty", PrimitiveSequenceTest.testAsCompleteable_Empty),
- ("testAsCompleteable_Error", PrimitiveSequenceTest.testAsCompleteable_Error),
+ ("testAsCompletable_Empty", PrimitiveSequenceTest.testAsCompletable_Empty),
+ ("testAsCompletable_Error", PrimitiveSequenceTest.testAsCompletable_Error),
  ] }
 }
 

Tests/RxSwiftTests/PrimitiveSequenceTest.swift

@@ -325,12 +325,12 @@ extension PrimitiveSequenceTest {
  }
 }
 
-// completeable
+// completable
 extension PrimitiveSequenceTest {
- func testCompleteable_Subscription_completed() {
- let xs = Completeable.empty()
+ func testCompletable_Subscription_completed() {
+ let xs = Completable.empty()
 
- var events: [CompleteableEvent] = []
+ var events: [CompletableEvent] = []
 
  _ = xs.subscribe { event in
  events.append(event)
@@ -339,10 +339,10 @@ extension PrimitiveSequenceTest {
  XCTAssertEqual(events, [.completed])
  }
 
- func testCompleteable_Subscription_error() {
- let xs = Completeable.error(testError)
+ func testCompletable_Subscription_error() {
+ let xs = Completable.error(testError)
 
- var events: [CompleteableEvent] = []
+ var events: [CompletableEvent] = []
 
  _ = xs.subscribe { event in
  events.append(event)
@@ -351,10 +351,10 @@ extension PrimitiveSequenceTest {
  XCTAssertEqual(events, [.error(testError)])
  }
 
- func testCompleteable_create_completed() {
+ func testCompletable_create_completed() {
  let scheduler = TestScheduler(initialClock: 0)
 
- var observer: ((CompleteableEvent) -> ())! = nil
+ var observer: ((CompletableEvent) -> ())! = nil
 
  var disposedTime: Int? = nil
 
@@ -369,7 +369,7 @@ extension PrimitiveSequenceTest {
  })
 
  let res = scheduler.start {
- Completeable.create { _observer in
+ Completable.create { _observer in
  observer = _observer
  return Disposables.create {
  disposedTime = scheduler.clock
@@ -384,10 +384,10 @@ extension PrimitiveSequenceTest {
  XCTAssertEqual(disposedTime, 201)
  }
 
- func testCompleteable_create_error() {
+ func testCompletable_create_error() {
  let scheduler = TestScheduler(initialClock: 0)
 
- var observer: ((CompleteableEvent) -> ())! = nil
+ var observer: ((CompletableEvent) -> ())! = nil
 
  var disposedTime: Int? = nil
 
@@ -402,7 +402,7 @@ extension PrimitiveSequenceTest {
  })
 
  let res = scheduler.start {
- Completeable.create { _observer in
+ Completable.create { _observer in
  observer = _observer
  return Disposables.create {
  disposedTime = scheduler.clock
@@ -417,16 +417,16 @@ extension PrimitiveSequenceTest {
  XCTAssertEqual(disposedTime, 201)
  }
 
- func testCompleteable_create_disposing() {
+ func testCompletable_create_disposing() {
  let scheduler = TestScheduler(initialClock: 0)
 
- var observer: ((CompleteableEvent) -> ())! = nil
+ var observer: ((CompletableEvent) -> ())! = nil
  var disposedTime: Int? = nil
  var subscription: Disposable! = nil
  let res = scheduler.createObserver(Never.self)
 
  scheduler.scheduleAt(201, action: {
- subscription = Completeable.create { _observer in
+ subscription = Completable.create { _observer in
  observer = _observer
  return Disposables.create {
  disposedTime = scheduler.clock
@@ -946,7 +946,7 @@ extension PrimitiveSequenceTest {
 }
 
 extension PrimitiveSequenceTest {
- func testAsCompleteable_Empty() {
+ func testAsCompletable_Empty() {
  let scheduler = TestScheduler(initialClock: 0)
 
  let xs = scheduler.createHotObservable([
@@ -955,8 +955,8 @@ extension PrimitiveSequenceTest {
  ])
 
  let res = scheduler.start { () -> Observable<Never> in
- let completeable: Completeable = xs.asCompleteable()
- return completeable.asObservable()
+ let completable: Completable = xs.asCompletable()
+ return completable.asObservable()
  }
 
  XCTAssertEqual(res.events, [
@@ -968,16 +968,16 @@ extension PrimitiveSequenceTest {
  ])
  }
 
- func testAsCompleteable_Error() {
+ func testAsCompletable_Error() {
  let scheduler = TestScheduler(initialClock: 0)
 
  let xs = scheduler.createHotObservable([
  error(210, testError, Never.self)
  ])
 
  let res = scheduler.start { () -> Observable<Never> in
- let completeable: Completeable = xs.asCompleteable()
- return completeable.asObservable()
+ let completable: Completable = xs.asCompletable()
+ return completable.asObservable()
  }
 
  XCTAssertEqual(res.events, [
@@ -990,12 +990,12 @@ extension PrimitiveSequenceTest {
  }
 
  #if TRACE_RESOURCES
- func testAsCompleteableReleasesResourcesOnComplete() {
- _ = Observable<Never>.empty().asCompleteable().subscribe({ _ in })
+ func testAsCompletableReleasesResourcesOnComplete() {
+ _ = Observable<Never>.empty().asCompletable().subscribe({ _ in })
  }
 
- func testAsCompleteableReleasesResourcesOnError() {
- _ = Observable<Never>.error(testError).asCompleteable().subscribe({ _ in })
+ func testAsCompletableReleasesResourcesOnError() {
+ _ = Observable<Never>.error(testError).asCompletable().subscribe({ _ in })
  }
  #endif
 }