data.json : handle Nil and PersistentList

Author: jmglov

pixie/data/json.pxi

@@ -8,24 +8,20 @@
   (write-string [this]))
 
 (defn- write-map [m]
-  (if (empty? m)
-    "{}"
-    (str "{ "
-         (->> m
-              (transduce (comp (map (fn [[k v]] (string/interp "$(write-string k)$: $(write-string v)$")))
-                               (interpose ", "))
-                         string-builder))
-         " }")))
+  (str "{"
+       (->> m
+            (transduce (comp (map (fn [[k v]] (string/interp "$(write-string k)$: $(write-string v)$")))
+                             (interpose ", "))
+                       string-builder))
+       "}"))
 
 (defn- write-sequential [xs]
-  (if (empty? xs)
-    "[]"
-    (str "[ "
-         (->> xs
-              (transduce (comp (map write-string)
-                               (interpose ", "))
-                         string-builder))
-         " ]")))
+  (str "["
+       (->> xs
+            (transduce (comp (map write-string)
+                             (interpose ", "))
+                       string-builder))
+       "]"))
 
 (defn- write-str [s]
   (string/interp "\"$s$\""))
@@ -34,10 +30,12 @@
   Character (write-string [this] (write-str this))
   Cons (write-string [this] (write-sequential this))
   EmptyList (write-string [this] (write-sequential this))
+  Nil (write-string [_] "null")
   Number (write-string [this] (str this))
   Keyword (write-string [this] (write-str (name this)))
   LazySeq (write-string [this] (write-sequential this))
   IMap (write-string [this] (write-map this))
   IVector (write-string [this] (write-sequential this))
+  PersistentList (write-string [this] (write-sequential this))
   Ratio (write-string [this] (str (float this)))
   String (write-string [this] (write-str this)))

tests/pixie/tests/data/test-json.pxi

@@ -10,19 +10,67 @@
   (assert= (json/read-string "{\"foo\": 42, \"bar\": [\"baz\"]}")
            {"foo" 42, "bar" ["baz"]}))
 
-(deftest test-write-string
-  (assert= (json/write-string {:strings {:a \a, :b "b", :c "", :d :d}
-                               :numbers {:one 1, :two 2.0, :three 3/1}
-                               :lists {:empty {:vector [], :list '(), :seq (take 0 (range))}
-                                       :non-empty {:vector [1 2 3], :list '(1 2 3), :seq (take 3 (range))}}
-                               :maps {:empty {}, :non-empty {:this "is covered, right? ;)"}}})
-           "{ \"numbers\": { \"three\": 3, \"two\": 2.000000, \"one\": 1 }, \"lists\": { \"empty\": { \"vector\": [], \"list\": [], \"seq\": [] }, \"non-empty\": { \"vector\": [ 1, 2, 3 ], \"list\": [ 1, 2, 3 ], \"seq\": [ 0, 1, 2 ] } }, \"maps\": { \"empty\": {}, \"non-empty\": { \"this\": \"is covered, right? ;)\" } }, \"strings\": { \"d\": \"d\", \"a\": \"a\", \"c\": \"\", \"b\": \"b\" } }"))
+(deftest test-strings
+  (assert-table [x y] (assert= (json/write-string x) y)
+                \a "\"a\""
+                "foo" "\"foo\""
+                :bar "\"bar\""
+                "" "\"\""))
+
+(deftest test-numbers
+  (assert-table [x y] (assert= (json/write-string x) y)
+                1 "1"
+                1.0 "1.000000"
+                0.1 "0.100000"
+                1.1 "1.100000"
+                1234.5678 "1234.567800"
+                -1 "-1"
+                -0.1 "-0.100000"
+                -1.1 "-1.100000"
+                -1234.5678 "-1234.567800"
+                1e1 "10.000000"
+                3/1 "3"))
+
+(deftest test-vectors
+  (assert-table [x y] (assert= (json/write-string x) y)
+                [] "[]"
+                [nil] "[null]"
+                [1 2] "[1, 2]"
+                [1 1.0 nil] "[1, 1.000000, null]"
+                ["foo" 42] "[\"foo\", 42]"))
+
+(deftest test-seqs
+  (assert-table [x y] (assert= (json/write-string x) y)
+                (take 0 (range)) "[]"
+                (take 1 (repeat nil)) "[null]"
+                (map identity [1 2]) "[1, 2]"
+                (reduce + [1 2 3]) "6"))
+
+(deftest test-lists
+  (assert-table [x y] (assert= (json/write-string x) y)
+                '() "[]"
+                '(nil) "[null]"
+                '(1 2) "[1, 2]"
+                '(1 1.0 nil) "[1, 1.000000, null]"
+                '("foo" 42) "[\"foo\", 42]"
+                (list) "[]"
+                (list nil) "[null]"
+                (list 1 2) "[1, 2]"
+                (list 1 1.0 nil) "[1, 1.000000, null]"
+                (list "foo" 42) "[\"foo\", 42]"))
+
+(deftest test-maps
+  (assert-table [x y] (assert= (json/write-string x) y)
+                {} "{}"
+                {:foo 42} "{\"foo\": 42}"
+                {"foo" 42} "{\"foo\": 42}"
+                {"foo" 42, "bar" nil} "{\"foo\": 42, \"bar\": null}"))
 
 (deftest test-round-trip
   (let [data {"foo" 1, "bar" [2 3]}]  ; won't work with keywords because the parser doesn't keywordise them (yet)
     (assert= (-> data json/write-string json/read-string)
              data))
 
-  (let [string "{ \"foo\": [ 1, 2, 3 ] }"]
+  (let [string "{\"foo\": [1, 2, 3]}"]
     (assert= (-> string json/read-string json/write-string)
              string)))