Updates phel to 0.3 and refactors code to support new data structures.

Author: mabasic

README.md

@@ -10,7 +10,7 @@ This Phel library is a wrapper library around PHP `json_encode` and `json_decode
 
 It converts Phel datastructures and basic types to a format that PHP understands before calling `(php/json_encode)`.
 
-It generates valid Phel datastructures (table, array) from given JSON strings using `(php/json_decode)`.    
+It generates valid Phel datastructures (map, vector) from given JSON strings using `(php/json_decode)`.    
 
 ## Installation
 
@@ -24,23 +24,23 @@ composer require mabasic/phel-json
 
 This Phel library has two public method:
 
-- `(json/encode value @{:depth 512 :flags 0})`
-- `(json/decode json @{:depth 512 :flags 0})` 
+- `(json/encode value {:depth 512 :flags 0})`
+- `(json/decode json {:depth 512 :flags 0})` 
 
 
 ```phel
 (ns your\namespace
     (:require mabasic\json\json))
 
-(def result (json/encode @{:name "Phel"  :type "lisp"}))
+(def result (json/encode {:name "Phel"  :type "lisp"}))
 
 # result
 # {"name": "Phel", "type": "lisp"}
 
 (println (json/decode result))
 
 # output
-# @{:name "Phel"  :type "Lisp"}
+# {:name "Phel"  :type "Lisp"}
 ```
 
 ## Sponsors & Backers

composer.json

@@ -12,7 +12,7 @@
     ],
     "minimum-stability": "dev",
     "require": {
-        "phel-lang/phel-lang": "^0.2"
+        "phel-lang/phel-lang": "^0.3"
     },
     "extra": {
         "phel": {

src/json.phel

@@ -18,7 +18,7 @@
     (float? x) (str x)
     true x))
 
-(defn encode [value & [@{:flags flags :depth depth}]]
+(defn encode [value & [{:flags flags :depth depth}]]
   (let [flags (or flags 0)
         depth (or depth 512)]
     (when (php/is_resource value) (throw (php/new Exception "Value can be any type except a resource.")))
@@ -29,15 +29,16 @@
 
 (defn- decode-value [x]
   (cond
-    (indexed? x) (for [v :in x] (decode-value v))
+    (indexed? x)
+    (for [v :in x] (decode-value v))
     (php-array? x)
-    (let [table @{}]
+    (let [hashmap (transient {})]
       (foreach [k v x]
-        (put table (keyword k) (decode-value v)))
-      table)
+        (put hashmap (keyword k) (decode-value v)))
+      (persistent hashmap))
     true x))
 
-(defn decode [json & [@{:flags flags :depth depth}]]
+(defn decode [json & [{:flags flags :depth depth}]]
   (let [flags (or flags 0)
         depth (or depth 512)]
     (when-not (string? json) (throw (php/new Exception "Json must be a string.")))

tests/decode/flags.phel

@@ -10,21 +10,21 @@
   (is
    (thrown-with-msg?
     Exception "Flags must be an integer."
-    (json/decode sample-data @{:flags "flags"}))
+    (json/decode sample-data {:flags "flags"}))
    "It tests if flags parameter is an integer."))
 
 (deftest flag
   (is
    (=
-    @{:employee @{:name "sonoo 0xC0" :salary 56000 :married true}}
-    (json/decode sample-data @{:flags JSON_INVALID_UTF8_IGNORE}))
+    {:employee {:name "sonoo 0xC0" :salary 56000 :married true}}
+    (json/decode sample-data {:flags JSON_INVALID_UTF8_IGNORE}))
    "It tests flags parameter with one flag."))
 
 (deftest flags
   (is
    (=
-    @{:employee @{:name "sonoo 0xC0" :salary 56000 :married true}}
-    (json/decode sample-data @{:flags (bit-or
-                                       JSON_INVALID_UTF8_IGNORE
-                                       JSON_INVALID_UTF8_SUBSTITUTE)}))
+    {:employee {:name "sonoo 0xC0" :salary 56000 :married true}}
+    (json/decode sample-data {:flags (bit-or
+                                      JSON_INVALID_UTF8_IGNORE
+                                      JSON_INVALID_UTF8_SUBSTITUTE)}))
    "It tests flags parameter with two flags."))

tests/decode/value.phel

@@ -7,14 +7,14 @@
 (deftest test-something
   (is
    (=
-    @{:firstName "Rack"
-      :lastName "Jackon"
-      :gender "man"
-      :age 24
-      :address @{:streetAddress "126"
-                 :city "San Jone"
-                 :state "CA"
-                 :postalCode "394221"}
-      :phoneNumbers @[@{:type "home"
-                        :number "7383627627"}]}
+    {:firstName "Rack"
+     :lastName "Jackon"
+     :gender "man"
+     :age 24
+     :address {:streetAddress "126"
+               :city "San Jone"
+               :state "CA"
+               :postalCode "394221"}
+     :phoneNumbers [{:type "home"
+                     :number "7383627627"}]}
     (json/decode sample-data))))

tests/encode/depth.phel

@@ -3,30 +3,30 @@
   (:require phel\test :refer [deftest is]))
 
 (deftest depth
-  (let [sample-data @[1 [2] [[3]]]]
+  (let [sample-data [1 [2] [[3]]]]
     (is
      (=
       "[1,[2],[[3]]]"
-      (json/encode sample-data @{:depth 3}))
+      (json/encode sample-data {:depth 3}))
      "It returns a string containing the JSON representation of the supplied value if depth is equal to or higher than entered depth.")
     (is
      (=
       false
-      (json/encode sample-data @{:depth 2}))
+      (json/encode sample-data {:depth 2}))
      "It returns false if data depth is higher than entered depth.")))
 
 (deftest invalid-depth
   (is
    (thrown-with-msg?
     Exception "Depth must be an integer."
     (json/encode
-     @{:and "a & b"}
-     @{:depth "depth"}))
+     {:and "a & b"}
+     {:depth "depth"}))
    "It tests if depth parameter is an integer.")
   (is
    (thrown-with-msg?
     Exception "Depth must be greater than zero."
     (json/encode
-     @{:and "a & b"}
-     @{:depth 0}))
+     {:and "a & b"}
+     {:depth 0}))
    "It tests if depth parameter is greater than zero."))

tests/encode/flags.phel

@@ -9,24 +9,24 @@
    (thrown-with-msg?
     Exception "Flags must be an integer."
     (json/encode
-     @{:and "a & b"}
-     @{:flags "flags"}))
+     {:and "a & b"}
+     {:flags "flags"}))
    "It tests if flags parameter is an integer."))
 
 (deftest flag
   (is
    (=
     "{\"and\":\"a \u0026 b\"}"
     (json/encode
-     @{:and "a & b"}
-     @{:flags JSON_HEX_AMP}))
+     {:and "a & b"}
+     {:flags JSON_HEX_AMP}))
    "It tests flags parameter with one flag."))
 
 (deftest flags
   (is
    (=
     "{\"comparison\":\"a \u003E b\",\"and\":\"a \u0026 b\"}"
     (json/encode
-     @{:comparison "a > b"  :and "a & b"}
-     @{:flags (bit-or JSON_HEX_AMP JSON_HEX_TAG)}))
+     {:comparison "a > b"  :and "a & b"}
+     {:flags (bit-or JSON_HEX_AMP JSON_HEX_TAG)}))
    "It tests flags parameter with two flags."))

tests/encode/keys.phel

@@ -4,49 +4,49 @@
 
 (deftest valid-keys
   (is
-   (= "{\"string\":\"String\"}" (json/encode @{"string" "String"}))
+   (= "{\"string\":\"String\"}" (json/encode {"string" "String"}))
    "It tests if string is a valid key.")
   (is
-   (= "{\"1\":\"One\"}" (json/encode @{1 "One"}))
+   (= "{\"1\":\"One\"}" (json/encode {1 "One"}))
    "It tests if integer is a valid key.")
   (is
-   (= "{\"3.14\":\"PI\"}" (json/encode @{3.14 "PI"}))
+   (= "{\"3.14\":\"PI\"}" (json/encode {3.14 "PI"}))
    "It tests if float is a valid key.")
   (is
-   (= "{\"keyword\":\"Keyword\"}" (json/encode @{:keyword "Keyword"}))
+   (= "{\"keyword\":\"Keyword\"}" (json/encode {:keyword "Keyword"}))
    "It tests if keyword is a valid key.")
   (is
-   (= "{\"symbol\":\"Symbol\"}" (json/encode @{'symbol "Symbol"}))
+   (= "{\"symbol\":\"Symbol\"}" (json/encode {'symbol "Symbol"}))
    "It tests if symbol is a valid key."))
 
 (deftest invalid-keys
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{(set 1 2 3) "Set"}))
+    (json/encode {(set 1 2 3) "Set"}))
    "It tests if set is a valid key.")
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{[1 2 3] "Tuple"}))
-   "It tests if tuple is a valid key.")
+    (json/encode {(list 1 2 3) "List"}))
+   "It tests if list is a valid key.")
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{@[1 2 3] "Array"}))
-   "It tests if array is a valid key.")
+    (json/encode {[1 2 3] "Vector"}))
+   "It tests if vector is a valid key.")
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{@{:hello "World!"} "Table"}))
-   "It tests if table is a valid key.")
+    (json/encode {{:hello "World!"} "Hash map"}))
+   "It tests if hash-map is a valid key.")
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{(php/new \stdClass) "stdClass"}))
+    (json/encode {(php/new \stdClass) "stdClass"}))
    "It tests if stdClass is a valid key.")
   (is
    (thrown-with-msg?
     Exception "Key can only be an integer, float, symbol, keyword or a string."
-    (json/encode @{(php/new \DateTime) "DateTime"}))
+    (json/encode {(php/new \DateTime) "DateTime"}))
    "It tests if DateTime is a valid key."))

tests/encode/value.phel

@@ -26,86 +26,86 @@
 (deftest test-symbol
   (is (= "\"symbol\"" (json/encode 'symbol))))
 
-(deftest test-tuple
+(deftest test-list
   (is (=
        "[1,2,3]"
-       (json/encode [1 2 3])))
+       (json/encode (list 1 2 3))))
   (is (=
        "[1,2,[1,2]]"
-       (json/encode [1 2 [1 2]])))
+       (json/encode (list 1 2 (list 1 2)))))
   (is (=
        "[1,2,\"string\"]"
-       (json/encode [1 2 "string"])))
+       (json/encode (list 1 2 "string"))))
   (is (=
        "[1,2,[1,2,3]]"
-       (json/encode [1 2 (set 1 2 3)])))
+       (json/encode (list 1 2 (set 1 2 3)))))
   (is (=
        "[1,2,[1,2,[1,2]]]"
-       (json/encode [1 2 (set 1 2 (set 1 2))])))
+       (json/encode (list 1 2 (set 1 2 (set 1 2))))))
   (is (=
        "[1,2,{\"year\":2020,\"planet\":\"Earth\"}]"
-       (json/encode [1 2 @{:year 2020
-                           "planet" "Earth"}])))
+       (json/encode (list 1 2 {:year 2020
+                               "planet" "Earth"}))))
   (is (=
-       "[1,2,{\"year\":2020,\"planet\":\"Earth\",\"tuple\":[\"multi\",\"ple\"]}]"
-       (json/encode [1 2 @{:year 2020
-                           "planet" "Earth"
-                           "tuple" ["multi" "ple"]}]))))
+       "[1,2,{\"year\":2020,\"planet\":\"Earth\",\"list\":[\"multi\",\"ple\"]}]"
+       (json/encode (list 1 2 {:year 2020
+                               "planet" "Earth"
+                               "list" (list "multi" "ple")})))))
 
-(deftest test-array
-  (is (= "[1,2,3]" (json/encode @[1 2 3])))
-  (is (= "[1,2,[1,2]]" (json/encode @[1 2 @[1 2]]))))
+(deftest test-vector
+  (is (= "[1,2,3]" (json/encode [1 2 3])))
+  (is (= "[1,2,[1,2]]" (json/encode [1 2 [1 2]]))))
 
 (deftest test-set
   (is (= "[1,2,3]" (json/encode (set 1 2 3))))
   (is (= "[1,2,[1,2]]" (json/encode (set 1 2 (set 1 2))))))
 
 (defstruct book [title pages year])
 
-(deftest test-table
+(deftest test-hash-map
   (is
    (=
     "{\"first_name\":\"Mario\",\"last_name\":\"Basic\"}"
-    (json/encode @{"first_name" "Mario"
-                   "last_name" "Basic"})))
+    (json/encode {"first_name" "Mario"
+                  "last_name" "Basic"})))
   (is
    (=
     "{\"first_name\":\"Mario\",\"last_name\":\"Basic\",\"set\":[1,2]}"
-    (json/encode @{"first_name" "Mario"
-                   "last_name" "Basic"
-                   "set" (set 1 2)})))
+    (json/encode {"first_name" "Mario"
+                  "last_name" "Basic"
+                  "set" (set 1 2)})))
   (is
    (=
     "{\"first_name\":\"Mario\",\"last_name\":\"Basic\",\"set\":[1,2,[3,4]]}"
-    (json/encode @{"first_name" "Mario"
-                   "last_name" "Basic"
-                   "set" (set 1 2 (set 3 4))})))
+    (json/encode {"first_name" "Mario"
+                  "last_name" "Basic"
+                  "set" (set 1 2 (set 3 4))})))
   (is
    (=
     "{\"first_name\":\"Mario\",\"last_name\":\"Basic\",\"set\":[1,2,[\"three\",4]]}"
-    (json/encode @{"first_name" "Mario"
-                   "last_name" "Basic"
-                   "set" (set 1 2 (set 'three 4))})))
+    (json/encode {"first_name" "Mario"
+                  "last_name" "Basic"
+                  "set" (set 1 2 (set 'three 4))})))
   (is
    (=
     "{\"first_name\":[\"Super\",\"mario\"],\"last_name\":\"Basic\"}"
-    (json/encode @{"first_name" @["Super"
-                                  :mario]
-                   "last_name" "Basic"})))
+    (json/encode {"first_name" ["Super"
+                                :mario]
+                  "last_name" "Basic"})))
   (is
    (=
     "{\"first_name\":[\"Super\",\"mario\"],\"last_name\":\"Basic\",\"3.14\":\"Value of PI.\"}"
-    (json/encode @{"first_name" @["Super"
-                                  :mario]
-                   "last_name" "Basic"
-                   3.14 "Value of PI."})))
+    (json/encode {"first_name" ["Super"
+                                :mario]
+                  "last_name" "Basic"
+                  3.14 "Value of PI."})))
   (let [dictionary (book "Dictionary" 100 2020)]
     (is
      (=
       "{\"first_name\":\"Mario\",\"last_name\":\"Basic\",\"authored\":{\"title\":\"Dictionary\",\"pages\":100,\"year\":2020}}"
-      (json/encode @{"first_name" "Mario"
-                     "last_name" "Basic"
-                     :authored dictionary})))))
+      (json/encode {"first_name" "Mario"
+                    "last_name" "Basic"
+                    :authored dictionary})))))
 
 (defstruct person [first_name last_name age])