Clean remnants of 0.1.0 qname handling

- qname function now returns canonical (keyword) names
- Remove QName defrecord from Clojurescript
- Rename canonical-name to as-qname
- Remove to-qname

Author: bendlas

CHANGES.md

@@ -1,3 +1,9 @@
+From 0.2.0-alpha1 to 0.2.0-alpha2
+- qname function now returns canonical (keyword) names
+- Remove QName defrecord from Clojurescript
+- Rename canonical-name to as-qname
+- Remove to-qname
+
 From 0.1.0-beta3 to 0.2.0-alpha1
 - Define uniform mapping of xml namespaces to clojure namespaces via percent-encoding
 - Remove declare-ns and alias-ns

src/main/clojure/clojure/data/xml.clj

@@ -34,14 +34,10 @@
 (export-api node/element* node/element node/cdata node/xml-comment
             prxml/sexp-as-element prxml/sexps-as-fragment event/element-nss
             name/alias-uri name/parse-qname name/qname-uri
-            name/qname-local name/qname name/to-qname name/uri-symbol name/symbol-uri
+            name/qname-local name/qname name/as-qname name/uri-symbol name/symbol-uri
+            name/uri-file name/print-uri-file-command!
             process/find-xmlns process/aggregate-xmlns)
 
-(defn canonical-name
-  "Put (q)name into canonical form as per ns-env"
-  [n]
-  (name/canonical-name (qname-uri n) (qname-local n) ""))
-
 (defn event-seq
   "Parses the XML InputSource source using a pull-parser. Returns
    a lazy sequence of Event records.  Accepts key pairs

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

@@ -8,15 +8,10 @@
    [clojure.data.xml.protocols :refer [AsQName]]))
 
 (export-api
- name/parse-qname name/qname-uri name/qname-local name/qname name/to-qname name/uri-symbol name/symbol-uri
+ name/parse-qname name/qname-uri name/qname-local name/qname name/as-qname name/uri-symbol name/symbol-uri
  node/element* node/element node/cdata node/xml-comment
  dom/extend-dom-as-data! dom/element-node dom/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
 ;; This probably won't happen due to js' non-blocking semantics
 ;; Instead, for clojurescript, the machinery around event-seq could be implemented

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

@@ -1,6 +1,6 @@
 (ns clojure.data.xml.js.dom
   (:require
-   [clojure.data.xml.name :refer [qname-uri qname-local canonical-name xmlns-uri]]
+   [clojure.data.xml.name :refer [qname-uri qname-local qname xmlns-uri]]
    [clojure.data.xml.node :as node]))
 
 (def doc
@@ -103,9 +103,8 @@
 ;; ## -> DATA
 
 (defn- dom-element-tag [el]
-  (canonical-name (.-namespaceURI el)
-                  (.-localName el)
-                  ""))
+  (qname (.-namespaceURI el)
+         (.-localName el)))
 
 (defn- xmlns-attr? [a]
   (identical? xmlns-uri (.-namespaceURI a)))

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

@@ -2,29 +2,20 @@
   (:require [clojure.data.xml.protocols :refer [AsQName qname-uri qname-local]]
             [clojure.string :as str]))
 
-(defrecord QName [uri local prefix]
-  AsQName
-  (qname-local [_] local)
-  (qname-uri [_] uri))
-
-(specify! (.-prototype QName)
-  IEquiv
-  (-equiv [this other]
-    (and (instance? QName other)
-         (= (.-local this) (.-local other))
-         (= (.-uri this) (.-uri other)))))
-
-(defn make-qname [uri name prefix]
-  (->QName uri name prefix))
-
 (def parse-qname
-  (memoize
-   (fn [s]
-     (let [[_ ns-uri local] (re-matches #"(?:\{([^}]+)\})?([^{]*)" s)]
-       (make-qname (or ns-uri "") local "")))))
+  (memoize (partial re-matches #"(?:\{([^}]+)\})?([^{]*)")))
 
 (defn decode-uri [ns]
   (js/decodeURIComponent ns))
 
 (defn encode-uri [uri]
   (js/encodeURIComponent uri))
+
+(extend-protocol AsQName
+  string
+  (qname-local [s]
+    (let [[_ _ local] (parse-qname s)]
+      local))
+  (qname-uri [s]
+    (let [[_ uri _] (parse-qname s)]
+      uri)))

src/main/clojure/clojure/data/xml/jvm/name.clj

@@ -19,14 +19,18 @@
   (qname-local [qname] (.getLocalPart qname))
   (qname-uri   [qname] (.getNamespaceURI qname)))
 
-(def parse-qname
+(def ^QName parse-qname
   (memoize
    (fn [s]
      ;; TODO weakly memoize this?
      (QName/valueOf s))))
 
-(definline make-qname [uri name prefix]
-  `(QName. ~uri ~name ~prefix))
+(extend-protocol AsQName
+  String
+  (qname-local [s]
+    (.getLocalPart (parse-qname s)))
+  (qname-uri [s]
+    (.getNamespaceURI (parse-qname s))))
 
 (definline decode-uri [ns]
   `(URLDecoder/decode ~ns "UTF-8"))

src/main/clojure/clojure/data/xml/jvm/parse.clj

@@ -14,7 +14,7 @@
             [clojure.data.xml.impl :refer
              [static-case]]
             [clojure.data.xml.name :refer
-             [canonical-name]])
+             [qname]])
   (:import
    (javax.xml.stream
     XMLInputFactory XMLStreamReader XMLStreamConstants)))
@@ -38,9 +38,9 @@
 (defn- attr-hash [^XMLStreamReader sreader]
   (persistent!
    (reduce (fn [tr i]
-             (assoc! tr (canonical-name (.getAttributeNamespace sreader i)
-                                        (.getAttributeLocalName sreader i)
-                                        (.getAttributePrefix sreader i))
+             (assoc! tr (qname (.getAttributeNamespace sreader i)
+                               (.getAttributeLocalName sreader i)
+                               (.getAttributePrefix sreader i))
                      (.getAttributeValue sreader i)))
            (transient {})
            (range (.getAttributeCount sreader)))))
@@ -74,13 +74,12 @@
                       (location-hash sreader))]
        (static-case
          (.next sreader)
-         ; condp == (.next sreader)
          XMLStreamConstants/START_ELEMENT
          (if (include-node? :element)
            (let [ns-env (nss-hash sreader (or (first ns-envs) {}))]
-             (cons (->StartElementEvent (canonical-name (.getNamespaceURI sreader)
-                                                        (.getLocalName sreader)
-                                                        (.getPrefix sreader))
+             (cons (->StartElementEvent (qname (.getNamespaceURI sreader)
+                                               (.getLocalName sreader)
+                                               (.getPrefix sreader))
                                         (attr-hash sreader)
                                         ns-env
                                         location)

src/main/clojure/clojure/data/xml/name.cljc

@@ -21,8 +21,8 @@
              (:import (goog.string StringBuffer))]))
 
 (export-api
- #?@(:clj  [jvm/parse-qname jvm/make-qname jvm/encode-uri jvm/decode-uri]
-     :cljs [jsn/parse-qname jsn/make-qname jsn/encode-uri jsn/decode-uri]))
+ #?@(:clj  [jvm/parse-qname jvm/encode-uri jvm/decode-uri]
+     :cljs [jsn/parse-qname jsn/encode-uri jsn/decode-uri]))
 
 ;; protocol functions can be redefined by extend-*, so we wrap
 ;; protocols/qname-uri protocols/qname-local within regular fns
@@ -47,9 +47,11 @@
   (protocols/qname-local v))
 
 (defn qname
-  ([name] (make-qname "" name ""))
-  ([uri name] (make-qname (or uri "") name ""))
-  ([uri name prefix] (make-qname (or uri "") name (or prefix ""))))
+  ([local] (qname "" local))
+  ([uri local] (keyword (when-not (str/blank? uri)
+                          (encode-uri (str "xmlns." uri)))
+                        local))
+  ([uri local prefix] (qname uri local)))
 
 ;; The empty string shall be equal to nil for xml names
 (defn namespaced? [qn]
@@ -76,28 +78,44 @@
           xmlns-uri
           (throw (ex-info "Keyword ns is not an xmlns. Needs to be in the form :xmlns.<encoded-uri>/<local>"
                           {:kw kw}))))
-      ""))
-  #?(:clj String :cljs string)
-  (qname-local [s] (qname-local (parse-qname s)))
-  (qname-uri   [s] (qname-uri (parse-qname s))))
-
-(defn canonical-name
-  ([local] (canonical-name "" local ""))
-  ([uri local] (canonical-name uri local ""))
-  ([uri local prefix]
-   (keyword (when-not (str/blank? uri)
-              (encode-uri (str "xmlns." uri)))
-            local)))
-
-(defn to-qname [n]
-  (make-qname (or (qname-uri n) "") (qname-local n) ""))
+      "")))
+
+(defn as-qname [n]
+  (qname (qname-uri n) (qname-local n)))
+
+(defn uri-file
+  "Dummy file name for :require'ing xmlns uri"
+  [uri]
+  (str (str/replace (name (uri-symbol uri))
+                    "." "/")
+       ".cljc"))
+
+(defn print-uri-file-command!
+  "Shell command to create a dummy file for xmlns. Execute from a source root."
+  [uri]
+  (println  "echo \"(ns" (str (uri-symbol uri) ")\" >") (uri-file uri)))
 
 #?(:clj
    (defn alias-uri
-     "Define a clojure namespace alias for xmlns uri.
+     "Define a Clojure namespace aliases for xmlns uris.
+
+  This sets up the current namespace for reading qnames denoted with
+  Clojure's ::alias/keywords reader feature.
+  
+
   ## Example
   (alias-uri :D \"DAV:\")
-  {:tag ::D/propfind}"
+                           ; similar in effect to
+  ;; (require '[xmlns.DAV%3A :as D])
+                           ; but required namespace is auto-created
+                           ; henceforth, shorthand keywords can be used
+  {:tag ::D/propfind}
+                           ; ::D/propfind will be expanded to :xmlns.DAV%3A/propfind
+                           ; in the current namespace by the reader
+
+  ## Clojurescript support
+  Currently, namespaces can't be auto-created in Clojurescript.
+  Dummy files for aliased uris have to exist. Have a look at `uri-file` and `print-uri-file-command!` to create those."
      {:arglists '([& {:as alias-nss}])}
      [& ans]
      (loop [[a n & rst :as ans] ans]

src/main/clojure/clojure/data/xml/node.cljc

@@ -9,17 +9,17 @@
 (ns clojure.data.xml.node
   "Data types for xml nodes: Element, CData and Comment"
   {:author "Herwig Hochleitner"}
-  (:require [clojure.data.xml.name :refer [to-qname]]))
+  (:require [clojure.data.xml.name :refer [as-qname]]))
 
 ;; Parsed data format
 ;; Represents a node of an XML tree
 (defrecord Element [tag attrs content]
   Object
   (toString [_]
-    (let [qname (to-qname tag)]
+    (let [qname (as-qname tag)]
       (apply str (concat ["<" qname]
                          (mapcat (fn [[n a]]
-                                   [" " (to-qname n) "=" (pr-str a)])
+                                   [" " (as-qname n) "=" (pr-str a)])
                                  attrs)
                          (if (seq content)
                            (concat [">"] content ["</" qname ">"])

src/main/resources/clojure/data/xml/spec.cljc

@@ -18,7 +18,7 @@
                    ::s/invalid)))
           (fn [{:keys [uri local] :as arg}]
             (.log js/console arg)
-            (name/canonical-name uri local "")))
+            (name/qname uri local)))
          #(not (str/blank? (:local %)))))
 
 (s/def ::name/qname
@@ -30,7 +30,7 @@
                      :str (s/and string? ::qname-conformer)))
    (s/with-gen
      #(gen/fmap (fn [[uri local]]
-                  (name/canonical-name uri local))
+                  (name/qname uri local))
                 (gen/tuple (gen/fmap (fn [s] (when-not (str/blank? s)
                                                (str "urn:" s)))
                                      (gen/string-alphanumeric))