CLJ-2469 Make fewer assumptions about maps when printing them

Signed-off-by: Stuart Halloway <stu@cognitect.com>

Author: puredanger

src/clj/clojure/core_print.clj

@@ -226,14 +226,14 @@
   (print-meta v w)
   (print-sequential "[" pr-on " " "]" v w))
 
-(defn- print-prefix-map [prefix m print-one w]
+(defn- print-prefix-map [prefix kvs print-one w]
   (print-sequential
     (str prefix "{")
-    (fn [e ^Writer w]
-      (do (print-one (key e) w) (.append w \space) (print-one (val e) w)))
+    (fn [[k v] ^Writer w]
+      (do (print-one k w) (.append w \space) (print-one v w)))
     ", "
     "}"
-    (seq m) w))
+    kvs w))
 
 (defn- print-map [m print-one w]
   (print-prefix-map nil m print-one w))
@@ -245,26 +245,26 @@
     (keyword nil (name named))))
 
 (defn- lift-ns
-  "Returns [lifted-ns lifted-map] or nil if m can't be lifted."
+  "Returns [lifted-ns lifted-kvs] or nil if m can't be lifted."
   [m]
   (when *print-namespace-maps*
     (loop [ns nil
            [[k v :as entry] & entries] (seq m)
-           lm {}]
+           kvs []]
       (if entry
-        (when (or (keyword? k) (symbol? k))
+        (when (qualified-ident? k)
           (if ns
             (when (= ns (namespace k))
-              (recur ns entries (assoc lm (strip-ns k) v)))
+              (recur ns entries (conj kvs [(strip-ns k) v])))
             (when-let [new-ns (namespace k)]
-              (recur new-ns entries (assoc lm (strip-ns k) v)))))
-        [ns (apply conj (empty m) lm)]))))
+              (recur new-ns entries (conj kvs [(strip-ns k) v])))))
+        [ns kvs]))))
 
 (defmethod print-method clojure.lang.IPersistentMap [m, ^Writer w]
   (print-meta m w)
-  (let [[ns lift-map] (lift-ns m)]
+  (let [[ns lift-kvs] (lift-ns m)]
     (if ns
-      (print-prefix-map (str "#:" ns) lift-map pr-on w)
+      (print-prefix-map (str "#:" ns) lift-kvs pr-on w)
       (print-map m pr-on w))))
 
 (defmethod print-dup java.util.Map [m, ^Writer w]

test/clojure/test_clojure/printer.clj

@@ -14,7 +14,8 @@
 ;;  Created 29 October 2008
 
 (ns clojure.test-clojure.printer
-  (:use clojure.test))
+  (:use clojure.test)
+  (:require [clojure.pprint :refer [pprint]]))
 
 (deftest print-length-empty-seq
   (let [coll () val "()"]
@@ -135,8 +136,49 @@
                                                {:with "even" :more 'data})))))))
 
 (deftest print-ns-maps
-  (is (= "#:user{:a 1}" (binding [*print-namespace-maps* true] (pr-str {:user/a 1}))))
-  (is (= "{:user/a 1}" (binding [*print-namespace-maps* false] (pr-str {:user/a 1}))))
+  (are [m s-on pp-on s-off]
+    (and (= s-on (binding [*print-namespace-maps* true] (pr-str m)))
+      (= pp-on (binding [*print-namespace-maps* true] (with-out-str (pprint m))))
+      (= s-off (binding [*print-namespace-maps* false] (pr-str m))))
+    {} "{}" "{}\n" "{}"
+    {:a 1, :b 2} "{:a 1, :b 2}" "{:a 1, :b 2}\n" "{:a 1, :b 2}"
+    {:user/a 1} "#:user{:a 1}" "#:user{:a 1}\n" "{:user/a 1}"
+    {:user/a 1, :user/b 2} "#:user{:a 1, :b 2}" "#:user{:a 1, :b 2}\n" "{:user/a 1, :user/b 2}"
+    {:user/a 1, :b 2} "{:user/a 1, :b 2}" "{:user/a 1, :b 2}\n" "{:user/a 1, :b 2}"
+    {:user/a 1, 'user/b 2} "#:user{:a 1, b 2}" "#:user{:a 1, b 2}\n" "{:user/a 1, user/b 2}"
+    {:user/a 1, :foo/b 2} "{:user/a 1, :foo/b 2}" "{:user/a 1, :foo/b 2}\n" "{:user/a 1, :foo/b 2}"
+
+    {:user/a 1, :user/b 2, 100 200}
+    "{:user/a 1, :user/b 2, 100 200}"
+    "{:user/a 1, :user/b 2, 100 200}\n"
+    "{:user/a 1, :user/b 2, 100 200}"
+
+    ;; CLJ-2469
+    (struct (create-struct :q/a :q/b :q/c) 1 2 3)
+    "#:q{:a 1, :b 2, :c 3}"
+    "#:q{:a 1, :b 2, :c 3}\n"
+    "{:q/a 1, :q/b 2, :q/c 3}"
+
+    ;; CLJ-2537
+    {:x.y/a {:rem 0}, :x.y/b {:rem 1}}
+    "#:x.y{:a {:rem 0}, :b {:rem 1}}"
+    "#:x.y{:a {:rem 0}, :b {:rem 1}}\n"
+    "{:x.y/a {:rem 0}, :x.y/b {:rem 1}}"
+
+    (into (sorted-map-by (fn [k1 k2]
+                           (when-not (every? qualified-ident? [k1 k2])
+                             (throw (RuntimeException. (str "Invalid keys:" [k1 k2]))))
+                           (compare k1 k2))
+            :x.y/a {:rem 0}, :x.y/b {:rem 1}))
+    "#:x.y{:a {:rem 0}, :b {:rem 1}}"
+    "#:x.y{:a {:rem 0}, :b {:rem 1}}\n"
+    "{:x.y/a {:rem 0}, :x.y/b {:rem 1}}"
+
+    (sorted-map-by #(compare %2 %1) :k/a 1 :k/b 2 :k/c 3 :k/d 4 :k/e 5 :k/f 6 :k/g 7 :k/h 8 :k/i 9)
+    "#:k{:i 9, :h 8, :g 7, :f 6, :e 5, :d 4, :c 3, :b 2, :a 1}"
+    "#:k{:i 9, :h 8, :g 7, :f 6, :e 5, :d 4, :c 3, :b 2, :a 1}\n"
+    "{:k/i 9, :k/h 8, :k/g 7, :k/f 6, :k/e 5, :k/d 4, :k/c 3, :k/b 2, :k/a 1}")
+
   (let [date-map (bean (java.util.Date. 0))]
     (is (= (binding [*print-namespace-maps* true] (pr-str date-map))
            (binding [*print-namespace-maps* false] (pr-str date-map))))))