correct 'reset!' and 'add-watch' to act like atoms. Added related tests.

Author: Frozenlock

Diff for: src/reagent/cursor.cljs

@@ -14,6 +14,7 @@
 
 ;; Implementation based on RAtom by delegation
 
+
 (deftype RCursor [path ratom]
   IAtom
 
@@ -26,7 +27,8 @@
 
   IReset
   (-reset! [a new-value]
-    (swap! ratom assoc-in path new-value))
+    (-> (swap! ratom assoc-in path new-value)
+        (get-in path)))
 
   ISwap
   (-swap! [a f]
@@ -65,24 +67,40 @@
   (-notify-watches [this oldval newval]
     (-notify-watches ratom oldval newval))
   (-add-watch [this key f]
-    (-add-watch ratom key f))
+    (-add-watch ratom [path key]
+                (fn [k r o n]
+                  (f key
+                     this
+                     (get-in o path)
+                     (get-in n path)))))
   (-remove-watch [this key]
-    (-remove-watch ratom key))
+    (-remove-watch ratom [path key]))
 
   IHash
   (-hash [this] (goog/getUid this)))
 
 ;; RCursor
 
 (defn cursor
-  "Provide a cursor into a Reagent atom.
+  "Provide a cursor into an atom.
+  
+  When called with a single argument, return a function that will
+  create a cursor given an atom.
 
-Behaves like a Reagent atom but focuses updates and derefs to
-the specified path within the wrapped Reagent atom. e.g.,
+  Behaves like an atom but focuses updates and derefs to the specified
+  path within the wrapped atom. e.g.,
   (let [c (cursor [:nested :content] ra)]
-    ... @c ;; equivalent to (get-in @ra [:nested :content])
-    ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
-    ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
-    )"
+  ... @c ;; equivalent to (get-in @ra [:nested :content])
+  ... (reset! c 42) ;; equivalent to (swap! ra assoc-in [:nested :content] 42)
+  ... (swap! c inc) ;; equivalence to (swap! ra update-in [:nested :content] inc)
+  )"
   ([path] (fn [ra] (cursor path ra)))
   ([path ra] (RCursor. path ra)))
+
+
+(defn cur
+  "Create a cursor. 
+
+  Behaves like a normal atom for the value at the specified path."
+  [a path]
+  (RCursor. path a))

Diff for: test/cursor_impl.cljs

@@ -0,0 +1,55 @@
+;; copyright (c) 2014 Frozenlock
+(ns cursor-impl
+  (:require-macros [cemerick.cljs.test
+                    :refer (is deftest with-test run-tests testing)])
+  (:require [cemerick.cljs.test :as t]
+            [reagent.cursor :as c]))
+
+;; Here we test if the cursors act as a normal atom
+
+(deftest values
+  (let [test-atom (atom {:a {:b {:c {:d 1}}}})
+        test-cursor (c/cur test-atom [:a :b :c :d])]
+
+    ;; get the initial values
+    (is (= (get-in @test-atom [:a :b :c :d])
+           @test-cursor))
+    
+    ;; now we update the cursor with a reset    
+    (reset! test-cursor 2)
+    (is (= @test-cursor 2))
+    (is (= (get-in @test-atom [:a :b :c :d]) 2))
+
+    ;; swap
+    (reset! test-cursor {}) ;; empty map
+    (swap! test-cursor assoc :z 3)
+    (is (= @test-cursor {:z 3}))
+    (is (= (get-in @test-atom [:a :b :c :d])
+           {:z 3}))))
+
+
+(deftest atom-behaviors
+  (let [test-atom (atom {:a {:b {:c {:d 1}}}})
+        test-cursor (c/cur test-atom [:a :b :c :d])
+        witness (atom nil)]
+    ;; per the description, reset! should return the new values
+    (is (= {}
+           (reset! test-cursor {})))
+    
+    ;; per the description, swap! should return the new values
+    (is (= {:z [1 2 3]}
+           (swap! test-cursor assoc :z [1 2 3])))
+
+    ;; watches should behave like with a normal atom
+    (reset! test-cursor "old")
+    (add-watch test-cursor :w #(reset! witness {:key %1 :ref %2 :old %3 :new %4}))
+    (reset! test-cursor "new") ;; this should trigger the watch function
+    (is (= (:key @witness) :w))
+    (is (= (:ref @witness) test-cursor))
+    (is (= (:old @witness) "old"))
+    (is (= (:new @witness) "new"))
+    ;; can we remove the watch?
+    (remove-watch test-cursor :w)
+    (reset! test-cursor "removed")
+    (is (= (:new @witness) "new")) ;; shouldn't have changed
+    ))