Issue#186 : updated take(until:) description and added unit test.

Prior to this change `take(until:)` was described as terminating the receiver only for a completed event on the given signal. This has been updated to accurately state that it is for _any_ event that was sent on the provided signal.

Unit Tests provided and full unit test suite passed.

Sources/SignalProtocol.swift

@@ -769,12 +769,13 @@ public extension SignalProtocol {
     }
   }
 
-  /// Emit elements of the reciver until given signal completes and then complete the receiver.
+  /// Emit elements of the receiver until the given signal sends an event (of any kind)
+  /// and then completes the receiver (subsequent events on the receiver are ignored).
   public func take<S: SignalProtocol>(until signal: S) -> Signal<Element, Error> {
     return Signal { observer in
       let disposable = CompositeDisposable()
-
-      disposable += signal.observe { event in
+      
+      disposable += signal.observe { _ in
         observer.completed()
       }
 

Tests/ReactiveKitTests/SignalTests.swift

@@ -217,6 +217,28 @@ class SignalTests: XCTestCase {
     let takenLast2 = operation.take(last: 2)
     takenLast2.expectComplete(after: [2, 3])
   }
+
+  func testTakeUntil() {
+    let bob = Scheduler()
+    let eve = Scheduler()
+
+    let operation = Signal<Int, TestError>.sequence([1, 2, 3, 4]).observeIn(bob.context)
+    let interrupt = Signal<String, TestError>.sequence(["A", "B"]).observeIn(eve.context)
+
+    let takeuntil = operation.take(until: interrupt)
+
+    let exp = expectation(description: "completed")
+    takeuntil.expectAsyncComplete(after: [1, 2], expectation: exp)
+
+    bob.runOne()                // Sends 1.
+    bob.runOne()                // Sends 2.
+    eve.runOne()                // Sends A, effectively stopping the receiver.
+    bob.runOne()                // Ignored.
+    eve.runRemaining()          // Ignored. Sends B, with termination.
+    bob.runRemaining()          // Ignored.
+
+    waitForExpectations(timeout: 1, handler: nil)
+  }
 
 //  func testThrottle() {
 //    let operation = Signal<Int, TestError>.interval(0.4, queue: Queue.global).take(5)