Implement beginning of cljs test suite

Multiple fixes:

- data extended dom now provides equality
- Provide reification to native nodes or to maps
- include a mock xml dom for tests in nashorn
  - unfortunately, this can't test native dom extension, since xmldom is spotty

Author: bendlas

.gitignore

@@ -2,3 +2,9 @@
 modules/xml/target/
 modules/xml.pull-parser/target/
 *~
+/out/
+/node_modules/
+/nashorn_code_cache/
+/figwheel_server.log
+/.nrepl-port
+/.cljs_nashorn_repl/

README.md

@@ -289,6 +289,39 @@ To elide location information, pass `:location-info false` to the parser:
 
     (parse-str your-input :location-info false)
 
+## Clojurescript support
+
+The Clojurescript implementation uses the same namespace as the Clojure one `clojure.data.xml`.
+
+### Differences from Clojure implementation
+
+data.xml uses native browser dom elements to represent xml. To get back the convenience of treating them as maps, call `(extend-dom-as-data!)`. This extends the native dom node prototypes to Clojurescript collection protocols, such that you can treat them as data.xml parse trees.
+
+Of course, the map format is supported for emitting.
+
+### Missing Features, Patches Welcome
+
+#### Streaming
+
+data.xml on Clojurescript doesn't currently support streaming, hence only the `*-str` variants of `parse`/`emit` are implemented. Those are just wrappers for browser's native xml parsing/printing.
+
+Pull parsing doesn't seem the right solution for Clojurescript, because when code cannot block, the parser has no way of waiting on its input. For this reason, parsing in Clojurescript cannot be based around `event-seq`.
+
+Push parsing, on the other hand should not pose a problem, because when data arrives in a callback, it can be pushed on into the parser. Fortunately, clojure already has a nice push-based pendant for lazy sequences: transducers.
+
+#### Utilities
+
+Some utilities, like `process/*-xmlns`, `prxml/sexp-as-*`, `indent` aren't yet implemented.
+
+#### Immutable updates for dom types
+
+Make `extend-dom-as-data!` also support assoc, ... on dom nodes.
+
+#### Data coercions
+
+
+
+
 ## License
 
 Licensed under the [Eclipse Public License](http://www.opensource.org/licenses/eclipse-1.0.php).

dxml-nashorn.global.js

@@ -0,0 +1,8 @@
+global.console = { 
+    log: print,
+    warn: print,
+    error: print
+};
+global.xmldom = require("xmldom");
+global.DOMParser = global.xmldom.DOMParser;
+global.XMLSerializer = global.xmldom.XMLSerializer;

package.json

@@ -0,0 +1,13 @@
+{
+
+    "scripts": {
+        "build": "webpack"
+    }
+
+    , "devDependencies": {
+        "webpack": "2.1.0-beta.27",
+        "xmldom" : "0.1.27"
+        "domino" : ""
+    }
+    , "name": "dxml-nashorn-api"
+}

pom.xml

@@ -48,6 +48,26 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <artifactId>maven-jar-plugin</artifactId>
+        <version>2.4</version>
+        <executions>
+          <execution>
+            <id>default-jar</id>
+            <phase>package</phase>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+            <configuration>
+              <includes>
+                <include>**/*.clj</include>
+                <include>**/*.cljs</include>
+                <include>**/*.cljc</include>
+              </includes>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
   </build>
 

project.clj

@@ -1,5 +1,10 @@
 (defproject org.clojure/data.xml "0-UE-DEVELOPMENT"
   :source-paths ["src/main/clojure"]
   :test-paths ["src/test/clojure"]
-  :resource-paths ["src/test/resources"]
-  :dependencies [[org.clojure/clojure "1.8.0"]])
+  :resource-paths ["src/test/resources" "target/gen-resources"]
+  :dependencies [[org.clojure/clojure "1.8.0"]
+                 [org.clojure/clojurescript "1.9.293"]
+                 [com.cemerick/piggieback "0.2.1"]
+                 [org.clojure/tools.nrepl "0.2.12"]
+                 [figwheel-sidecar "0.5.8"]]
+  :repl-options {:nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]})

src/main/clojure/clojure/data/xml.cljs

@@ -7,30 +7,37 @@
    [clojure.data.xml.protocols :refer [AsQName]]))
 
 (export-api
- name/parse-qname name/qname-uri name/qname-local name/qname name/to-qname
- node/element* node/element node/cdata node/xml-comment)
+ name/parse-qname name/qname-uri name/qname-local name/qname name/to-qname name/uri-symbol
+ node/element* node/element node/cdata node/xml-comment node/text-node
+ node/extend-dom-as-data! node/element-node node/element-data)
 
 (defn canonical-name
   "Put (q)name into canonical form as per ns-env"
   [n]
   (name/canonical-name (qname-uri n) (qname-local n) ""))
 
-;; TODO event-seq
+;;;; ## TODO event-seq
+;; This probably won't happen due to js' non-blocking semantics
+;; Instead, for clojurescript, the machinery around event-seq could be implemented
+;; as a transducer stack, such that a push-based source for parser events, like sax-js,
+;; could be used.
+
 ;; TODO parse (use goog StringBuffer?)
 
 (defn parse-str
   "Use DOMParser to parse xml string"
   ;; TODO detect browser specific parsererror tags
   ;;  see http://stackoverflow.com/questions/11563554/how-do-i-detect-xml-parsing-errors-when-using-javascripts-domparser-in-a-cross
-  [s & {:keys [content-type on-error]
+  [s & {:keys [content-type on-error raw]
         :or {content-type "text/xml"
              on-error #(throw "XML parser error" {:doc % :input s})}}]
   (let [dom (. (js/DOMParser.)
                (parseFromString s content-type))
         doc (.-documentElement dom)]
-    (if (= "parsererror" (.-nodeName doc))
-      (on-error doc)
-      doc)))
+    (cond (= "parsererror" (.-nodeName doc))
+          (on-error doc)
+          raw doc
+          :else (element-data doc))))
 
 ;; TODO emit (use goog StringBuffer?)
 
@@ -39,68 +46,5 @@
   [e & {:keys []}]
   (. (js/XMLSerializer.)
      (serializeToString
-      (node/coerce-to-dom e))))
-
-(defn extend-nodes-as-qname! []
-  (extend-protocol AsQName
-    js/Element
-    (qname-local [e] (.-localName e))
-    (qname-uri [e] (.-namespaceURI e))
-    js/Attr
-    (qname-local [e] (.-localName e))
-    (qname-uri [e] (.-namespaceURI e))))
-
-(defn- as-node [n]
-  (if (instance? js/Text n)
-    (.-wholeText n) ;; .-data
-    n))
-
-(defn extend-dom-as-data! []
-  (extend-type js/Element
-    ILookup
-    (-lookup [el k]
-      (case k
-        :tag (name/canonical-name (.-namespaceURI el)
-                                  (.-localName el)
-                                  "")
-        :attrs (.-attributes el)
-        :content (.-childNodes el)
-        (throw "XML tag has no key" {:key k :el el}))))
-  (extend-type js/NamedNodeMap
-    ILookup
-    (-lookup
-      ([attrs attr]
-       (if-let [i (.getNamedItemNS attrs (qname-uri attr) (qname-local attr))]
-         (.-value i)
-         nil))
-      ([attrs attr not-found]
-       (if-let [i (.getNamedItemNS attrs (qname-uri attr) (qname-local attr))]
-         (.-value i)
-         not-found))))
-  (extend-type js/NodeList
-    ISeqable
-    (-seq [nl] (map as-node (array-seq nl)))
-    ISequential
-    ICounted
-    (-count [nl] (.-length nl))
-    IIndexed
-    (-nth
-      ([nl n]
-       (as-node (aget nl n)))
-      ([nl n nf]
-       (if (and (<= 0 n) (< n (.-length nl)))
-         (as-node (aget nl n))
-         nf)))))
-
-(comment
-
-  (extend-dom-as-data!)
-  (extend-nodes-as-qname!)
+      (node/element-node e))))
 
-  (let [{tag :tag {a1 "{DAV:}a1" a2 "a2" :as attrs} :attrs [c1 c2 c3] :content}
-        (parse-str "<xml xmlns:d=\"DAV:\" d:a1=\"dav-a1\" a2=\"normal a2\">
-Fancy Content <br/> More
-</xml>")]
-    [tag a1 a2 c1 c2 c3])
-  
-  )