Add Update operation. Fix Insert operation. Add tests.

The Insert operation was previously using the subscript behavior.
This meant object being inserted were not inserted but overwrote
the value at that index. In order to allow for proper behavior for
both subscripting and inserting and extra Operation of .Update was
added. Tests were augmented to ensure proper behavior.

Author: jkennington

ReactiveArray/Operation.swift

@@ -12,6 +12,7 @@ public enum Operation<T>: CustomDebugStringConvertible {
 
     case Append(value: T)
     case Insert(value: T, atIndex: Int)
+    case Update(value: T, atIndex: Int)
     case RemoveElement(atIndex: Int)
 
     public func map<U>(mapper: T -> U) -> Operation<U> {
@@ -21,6 +22,8 @@ public enum Operation<T>: CustomDebugStringConvertible {
             result = Operation<U>.Append(value: mapper(value))
         case .Insert(let value, let index):
             result = Operation<U>.Insert(value: mapper(value), atIndex: index)
+        case .Update(let value, let index):
+            result = Operation<U>.Update(value: mapper(value), atIndex: index)
         case .RemoveElement(let index):
             result = Operation<U>.RemoveElement(atIndex: index)
         }
@@ -34,6 +37,8 @@ public enum Operation<T>: CustomDebugStringConvertible {
             description = ".Append(value:\(value))"
         case .Insert(let value, let index):
             description = ".Insert(value: \(value), atIndex:\(index))"
+        case .Update(let value, let index):
+            description = ".Update(value: \(value), atIndex:\(index))"
         case .RemoveElement(let index):
             description = ".RemoveElement(atIndex:\(index))"
         }
@@ -46,6 +51,8 @@ public enum Operation<T>: CustomDebugStringConvertible {
             return value
         case .Insert(let value, _):
             return value
+        case .Update(let value, _):
+            return value
         default:
             return Optional.None
         }
@@ -59,6 +66,8 @@ public func ==<T: Equatable>(lhs: Operation<T>, rhs: Operation<T>) -> Bool {
         return leftValue == rightValue
     case (.Insert(let leftValue, let leftIndex), .Insert(let rightValue, let rightIndex)):
         return leftIndex == rightIndex && leftValue == rightValue
+    case (.Update(let leftValue, let leftIndex), .Update(let rightValue, let rightIndex)):
+        return leftIndex == rightIndex && leftValue == rightValue
     case (.RemoveElement(let leftIndex), .RemoveElement(let rightIndex)):
         return leftIndex == rightIndex
     default:

ReactiveArray/ReactiveArray.swift

@@ -103,7 +103,7 @@ public final class ReactiveArray<T>: CollectionType, MutableCollectionType, Cust
             return _elements[index]
         }
         set(newValue) {
-            insert(newValue, atIndex: index)
+            update(newValue, atIndex: index)
         }
     }
 
@@ -117,6 +117,11 @@ public final class ReactiveArray<T>: CollectionType, MutableCollectionType, Cust
         _sink(Event.Next(operation))
     }
 
+    public func update(element: T, atIndex index: Int) {
+        let operation: Operation<T> = .Update(value: element, atIndex: index)
+        _sink(Event.Next(operation))
+    }
+    
     public func removeAtIndex(index:Int) {
         let operation: Operation<T> = .RemoveElement(atIndex: index)
         _sink(Event.Next(operation))
@@ -136,6 +141,8 @@ public final class ReactiveArray<T>: CollectionType, MutableCollectionType, Cust
             _elements.append(value)
             _mutableCount.value = _elements.count
         case .Insert(let value, let index):
+            _elements.insert(value, atIndex: index)
+        case .Update(let value, let index):
             _elements[index] = value
         case .RemoveElement(let index):
             _elements.removeAtIndex(index)

ReactiveArrayTests/OperationSpec.swift

@@ -49,6 +49,21 @@ class OperationSpec: QuickSpec {
 
             }
 
+            context("when the operation is an Update operation") {
+                
+                beforeEach {
+                    operation = Operation.Update(value: 10, atIndex: 5)
+                }
+                
+                it("maps the value to be updated") {
+                    let mappedOperation = operation.map { $0 * 2 }
+                    
+                    let areEqual = mappedOperation == Operation.Update(value: 20, atIndex: 5)
+                    expect(areEqual).to(beTrue())
+                }
+                
+            }
+            
             context("when the operation is a Delete operation") {
 
                 beforeEach {
@@ -92,6 +107,18 @@ class OperationSpec: QuickSpec {
 
             }
 
+            context("when the operation is an Update operation") {
+                
+                beforeEach {
+                    operation = Operation.Update(value: 10, atIndex: 5)
+                }
+                
+                it("returns the updated value") {
+                    expect(operation.value).to(equal(10))
+                }
+                
+            }
+            
             context("when the operation is an Remove operation") {
 
                 beforeEach {

ReactiveArrayTests/ReactiveArraySpec.swift

@@ -15,6 +15,7 @@ private func waitForOperation<T>(fromProducer producer: SignalProducer<Operation
     when: () -> (),
     onAppend: T -> () = { fail("Invalid operation type: .Append(\($0))") },
     onInsert: (T, Int) -> () = { fail("Invalid operation type: .Insert(\($0), \($1))") },
+    onUpdate: (T, Int) -> () = { fail("Invalid operation type: .Update(\($0), \($1))") },
     onDelete: Int -> () = { fail("Invalid operation type: .Delete(\($0))") }) {
 
         waitUntil { done in
@@ -24,6 +25,8 @@ private func waitForOperation<T>(fromProducer producer: SignalProducer<Operation
                     onAppend(value)
                 case .Insert(let value, let index):
                     onInsert(value, index)
+                case .Update(let value, let index):
+                    onUpdate(value, index)
                 case .RemoveElement(let index):
                     onDelete(index)
                 }
@@ -38,19 +41,21 @@ private func waitForOperation<T>(fromSignal signal: Signal<Operation<T>, NoError
     when: () -> (),
     onAppend: T -> () = { fail("Invalid operation type: .Append(\($0))") },
     onInsert: (T, Int) -> () = { fail("Invalid operation type: .Insert(\($0), \($1))") },
+    onUpdate: (T, Int) -> () = { fail("Invalid operation type: .Update(\($0), \($1))") },
     onDelete: Int -> () = { fail("Invalid operation type: .Delete(\($0))") }) {
 
     let producer = SignalProducer<Operation<T>, NoError> { (observer, disposable) in signal.observe(observer) }
-    waitForOperation(fromProducer: producer, when: when, onAppend: onAppend, onInsert: onInsert, onDelete: onDelete)
+    waitForOperation(fromProducer: producer, when: when, onAppend: onAppend, onInsert: onInsert, onUpdate: onUpdate, onDelete: onDelete)
 }
 
 private func waitForOperation<T>(fromArray array: ReactiveArray<T>,
     when: () -> (),
     onAppend: T -> () = { fail("Invalid operation type: .Append(\($0))") },
     onInsert: (T, Int) -> () = { fail("Invalid operation type: .Insert(\($0), \($1))") },
+    onUpdate: (T, Int) -> () = { fail("Invalid operation type: .Update(\($0), \($1))") },
     onDelete: Int -> () = { fail("Invalid operation type: .Delete(\($0))") }) {
 
-    waitForOperation(fromSignal: array.signal, when: when, onAppend: onAppend, onInsert: onInsert, onDelete: onDelete)
+    waitForOperation(fromSignal: array.signal, when: when, onAppend: onAppend, onInsert: onInsert, onUpdate: onUpdate, onDelete: onDelete)
 }
 
 class ReactiveArraySpec: QuickSpec {
@@ -101,6 +106,7 @@ class ReactiveArraySpec: QuickSpec {
                     array.insert(5, atIndex: 1)
 
                     expect(array[1]).to(equal(5))
+                    expect(array.toArray()).to(equal([1,5,2,3,4]))
                 }
 
                 it("signals an insert operation") {
@@ -171,15 +177,16 @@ class ReactiveArraySpec: QuickSpec {
                     array[1] = 5
 
                     expect(array[1]).to(equal(5))
+                    expect(array.toArray()).to(equal([1,5,3,4]))
                 }
 
-                it("signals an insert operation") {
+                it("signals an update operation") {
                     waitForOperation(
                         fromArray: array,
                         when: {
                             array[1] = 5
                         },
-                        onInsert: { (value, index) in
+                        onUpdate: { (value, index) in
                             expect(value).to(equal(5))
                             expect(index).to(equal(1))
                         }
@@ -210,7 +217,7 @@ class ReactiveArraySpec: QuickSpec {
                         when: {
                             array[1] = 5
                         },
-                        onInsert: { (value, index) in
+                        onUpdate: { (value, index) in
                             expect(value).to(equal(15))
                             expect(index).to(equal(1))
                         }
@@ -365,6 +372,23 @@ class ReactiveArraySpec: QuickSpec {
 
             }
 
+            context("when an update operation is executed") {
+                
+                it("signals the operations") {
+                    waitForOperation(
+                        fromSignal: array.signal,
+                        when: {
+                            array[1] = 5
+                        },
+                        onUpdate: { (value, index) in
+                            expect(value).to(equal(5))
+                            expect(index).to(equal(1))
+                        }
+                    )
+                }
+                
+            }
+            
             context("when a delete operation is executed") {
 
                 it("signals the operations") {
@@ -411,7 +435,7 @@ class ReactiveArraySpec: QuickSpec {
                             .take(1)
                             .collect()
                             .startWithNext { counts in
-                                expect(counts).to(equal([countBeforeOperation + 1]))
+                                expect(counts).to(equal([countBeforeOperation + 2]))
                                 done()
                             }
 
@@ -422,6 +446,21 @@ class ReactiveArraySpec: QuickSpec {
 
             }
 
+            context("when an update operation is executed") {
+                
+                beforeEach {
+                    producer = producer.skip(1)
+                }
+                
+                it("updates the count") {
+                    waitUntil { done in
+                        array[1] = 656
+                        expect(array.count).to(equal(countBeforeOperation))
+                        done()
+                    }
+                }
+                
+            }
 
             context("when an append operation is executed") {