CLJS-2999: Update datafy to use inherent support for protocols via metadata

- Moves cljs.core/IDatafiable to clojure.core.protocols/Datafiable
- Moves cljs.core/INavigable to clojure.core.protocols/Navigable
- Enables :extend-via-metadata on Datafiable and Navigable

fix tests

Author: Will Acton

src/main/cljs/cljs/core.cljs

@@ -867,13 +867,6 @@
   (-iterator [coll]
     "Returns an iterator for coll."))
 
-(defprotocol IDatafiable
-  (-datafy [o] "return a representation of o as data (default identity)"))
-
-(defprotocol INavigable
-  (-nav [coll k v] "return (possibly transformed) v in the context of coll and k (a key/index or nil),
-defaults to returning v."))
-
 ;; Printing support
 
 (deftype StringBufferWriter [sb]
@@ -1366,10 +1359,7 @@ defaults to returning v."))
 
 (extend-type nil
   ICounted
-  (-count [_] 0)
-
-  IDatafiable
-  (-datafy [_] nil))
+  (-count [_] 0))
 
 ;; TODO: we should remove this and handle date equality checking
 ;; by some other means, probably by adding a new primitive type
@@ -1418,13 +1408,7 @@ defaults to returning v."))
 (extend-type default
   IHash
   (-hash [o]
-    (goog/getUid o))
-
-  IDatafiable
-  (-datafy [o] o)
-
-  INavigable
-  (-nav [_ _ x] x))
+    (goog/getUid o)))
 
 ;;this is primitive because & emits call to array-seq
 (defn inc

src/main/cljs/clojure/core/protocols.cljs

@@ -0,0 +1,29 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.core.protocols)
+
+(defprotocol Datafiable
+  :extend-via-metadata true
+  (datafy [o] "return a representation of o as data (default identity)"))
+
+(extend-protocol Datafiable
+  nil
+  (datafy [_] nil)
+
+  default
+  (datafy [o] o))
+
+(defprotocol Navigable
+  :extend-via-metadata true
+  (nav [coll k v] "return (possibly transformed) v in the context of coll and k (a key/index or nil),
+defaults to returning v."))
+
+(extend-protocol Navigable
+  default
+  (nav [_ _ x] x))

src/main/cljs/clojure/datafy.cljs

@@ -8,48 +8,50 @@
 
 (ns
   ^{:doc "Functions to turn objects into data. Alpha, subject to change"}
-  clojure.datafy)
+    clojure.datafy
+  (:require [clojure.core.protocols :as p]))
 
 (defn datafy
-  "Attempts to return x as data. If :clojure.datafy/datafy is present
-  as metadata of x, it will be called with x as an argument, else
-  datafy will return the value of clojure.protocols/datafy. If the
-  value has been transformed and the result supports
+  "Attempts to return x as data.
+  datafy will return the value of clojure.protocols/datafy. If
+  the value has been transformed and the result supports
   metadata, :clojure.datafy/obj will be set on the metadata to the
   original value of x."
   [x]
-  (let [v ((or (-> x meta ::datafy) -datafy) x)]
+  (let [v (p/datafy x)]
     (if (identical? v x)
       v
       (if (implements? IWithMeta v)
-        (vary-meta v assoc ::obj x)
+        (vary-meta v assoc ::obj x
+                   ;; Circling back to this at a later date per @dnolen
+                   ;; ::class (-> x .-constructor .-name symbol)
+                   )
         v))))
 
 (defn nav
   "Returns (possibly transformed) v in the context of coll and k (a
   key/index or nil). Callers should attempt to provide the key/index
   context k for Indexed/Associative/ILookup colls if possible, but not
-  to fabricate one e.g. for sequences (pass nil). If :clojure.datafy/nav is
-  present as metadata on coll, it will be called with coll, k and v as
-  arguments, else nav will call :clojure.protocols/nav."
+  to fabricate one e.g. for sequences (pass nil). nav will return the
+  value of clojure.core.protocols/nav."
   [coll k v]
-  ((or (-> coll meta ::nav) -nav) coll k v))
+  (p/nav coll k v))
 
 (defn- datify-ref [r]
   (with-meta [(deref r)] (meta r)))
 
-(extend-protocol IDatafiable
+(extend-protocol p/Datafiable
   Var
-  (-datafy [r] (datify-ref r))
+  (datafy [r] (datify-ref r))
 
   Reduced
-  (-datafy [r] (datify-ref r))
+  (datafy [r] (datify-ref r))
 
   Atom
-  (-datafy [r] (datify-ref r))
+  (datafy [r] (datify-ref r))
 
   Volatile
-  (-datafy [r] (datify-ref r))
+  (datafy [r] (datify-ref r))
 
   Delay
-  (-datafy [r] (datify-ref r)))
+  (datafy [r] (datify-ref r)))

src/test/cljs/clojure/datafy_test.cljs

@@ -14,11 +14,11 @@
 (deftest datafy-test
   (testing "Datafy works when datafied value is arbitrary JS objects"
     (let [datafied #js {}
-          x (with-meta [1 2 3] {:clojure.datafy/datafy (fn [_] datafied)})]
+          x (with-meta [1 2 3] {`clojure.core.protocols/datafy (fn [_] datafied)})]
       (is (= datafied (d/datafy x)))))
   (testing "Datafy adds ::obj metadata when return value != original value and supports metadata"
     (let [datafied [2 3 4]
           original [1 2 3]
-          x (with-meta original {:clojure.datafy/datafy (fn [_] datafied)})]
+          x (with-meta original {`clojure.core.protocols/datafy (fn [_] datafied)})]
       (is (= datafied (d/datafy x)))
       (is (= {:clojure.datafy/obj original} (meta (d/datafy x)))))))