You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

104 lines
4.0 KiB

14 years ago
  1. Jiffy - JSON NIFs for Erlang
  2. ============================
  3. A JSON parser as a NIF. This is a complete rewrite of the work I did
  4. in EEP0018 that was based on Yajl. This new version is a hand crafted
  5. state machine that does its best to be as quick and efficient as
  6. possible while not placing any constraints on the parsed JSON.
  7. [![Build Status](https://travis-ci.org/davisp/jiffy.svg?branch=master)](https://travis-ci.org/davisp/jiffy)
  8. Usage
  9. -----
  10. Jiffy is a simple API. The only thing that might catch you off guard
  11. is that the return type of `jiffy:encode/1` is an iolist even though
  12. it returns a binary most of the time.
  13. A quick note on unicode. Jiffy only understands UTF-8 in binaries. End
  14. of story.
  15. Errors are raised as exceptions.
  16. Eshell V5.8.2 (abort with ^G)
  17. 1> jiffy:decode(<<"{\"foo\": \"bar\"}">>).
  18. {[{<<"foo">>,<<"bar">>}]}
  19. 2> Doc = {[{foo, [<<"bing">>, 2.3, true]}]}.
  20. {[{foo,[<<"bing">>,2.3,true]}]}
  21. 3> jiffy:encode(Doc).
  22. <<"{\"foo\":[\"bing\",2.3,true]}">>
  23. `jiffy:decode/1,2`
  24. ------------------
  25. * `jiffy:decode(IoData)`
  26. * `jiffy:decode(IoData, Options)`
  27. The options for decode are:
  28. * `{bytes_per_iter, N}` where N &gt;= 0 - This controls the number of
  29. bytes that Jiffy will process before yielding back to the VM. The
  30. mechanics of this yield are completely hidden from the end user.
  31. * `return_maps` - Tell Jiffy to return objects using the maps data type
  32. on VMs that support it. This raises an error on VMs that don't support
  33. maps.
  34. * `{null_term, Term}` - Returns the specified `Term` instead of `null`
  35. when decoding JSON. This is for people that wish to use `undefined`
  36. instead of `null`.
  37. * `use_nil` - Returns the atom `nil` instead of `null` when decoding
  38. JSON. This is a short hand for `{null_term, nil}`.
  39. `jiffy:encode/1,2`
  40. ------------------
  41. * `jiffy:encode(EJSON)`
  42. * `jiffy:encode(EJSON, Options)`
  43. where EJSON is a valid representation of JSON in Erlang according to
  44. the table below.
  45. The options for encode are:
  46. * `uescape` - Escapes UTF-8 sequences to produce a 7-bit clean output
  47. * `pretty` - Produce JSON using two-space indentation
  48. * `force_utf8` - Force strings to encode as UTF-8 by fixing broken
  49. surrogate pairs and/or using the replacement character to remove
  50. broken UTF-8 sequences in data.
  51. * `{bytes_per_iter, N}` where N &gt;= 0 - This controls the number of
  52. bytes that Jiffy will generate before yielding back to the VM. The
  53. mechanics of this yield are completely hidden from the end user.
  54. * `escape_forward_slashes` - Escapes the `/` character which can be
  55. useful when encoding URLs in some cases.
  56. Data Format
  57. -----------
  58. Erlang JSON Erlang
  59. ==========================================================================
  60. null -> null -> null
  61. true -> true -> true
  62. false -> false -> false
  63. "hi" -> [104, 105] -> [104, 105]
  64. <<"hi">> -> "hi" -> <<"hi">>
  65. hi -> "hi" -> <<"hi">>
  66. 1 -> 1 -> 1
  67. 1.25 -> 1.25 -> 1.25
  68. [] -> [] -> []
  69. [true, 1.0] -> [true, 1.0] -> [true, 1.0]
  70. {[]} -> {} -> {[]}
  71. {[{foo, bar}]} -> {"foo": "bar"} -> {[{<<"foo">>, <<"bar">>}]}
  72. {[{<<"foo">>, <<"bar">>}]} -> {"foo": "bar"} -> {[{<<"foo">>, <<"bar">>}]}
  73. #{<<"foo">> => <<"bar">>} -> {"foo": "bar"} -> #{<<"foo">> => <<"bar">>}
  74. N.B. The last entry in this table is only valid for VM's that support
  75. the `maps` data type (i.e., 17.0 and newer) and client code must pass
  76. the `return_maps` option to `jiffy:decode/2`.
  77. Improvements over EEP0018
  78. -------------------------
  79. Jiffy should be in all ways an improvement over EEP0018. It no longer
  80. imposes limits on the nesting depth. It is capable of encoding and
  81. decoding large numbers and it does quite a bit more validation of UTF-8 in strings.