Merge pull request #16 from jkennington/master

Add .Update operation and fix .Insert operation

Author: Guido Marucci Blas

ReactiveArray/Info.plist

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.3.0</string>
+	<string>0.4.0</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>

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") {