%%%---------------------------------------------------------------------
%%% @copyright 2023 William Fank Thomé
%%% @author William Fank Thomé <willilamthome@hotmail.com>
%%% @doc JSON generator.
%%%
%%% Copyright 2023 William Fank Thomé
%%%
%%% Licensed under the Apache License, Version 2.0 (the "License");
%%% you may not use this file except in compliance with the License.
%%% You may obtain a copy of the License at
%%%
%%% http://www.apache.org/licenses/LICENSE-2.0
%%%
%%% Unless required by applicable law or agreed to in writing, software
%%% distributed under the License is distributed on an "AS IS" BASIS,
%%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%%% See the License for the specific language governing permissions and
%%% limitations under the License.
%%%
%%% @end
%%%---------------------------------------------------------------------
-module(euneus_encoder).
-compile({ inline, plugins/3 }).
-compile({ inline, drop_nulls/2 }).
-compile({ inline, encode_binary/2 }).
-compile({ inline, encode_atom/2 }).
-compile({ inline, encode_integer/2 }).
-compile({ inline, encode_float/2 }).
-compile({ inline, encode_list/2 }).
-compile({ inline, encode_map/2 }).
-compile({ inline, encode_unhandled/2 }).
-compile({ inline, escape_json/4 }).
-compile({ inline, escape_json_chunk/5 }).
-compile({ inline, escape_html/4 }).
-compile({ inline, escape_html_chunk/5 }).
-compile({ inline, escape_js/4 }).
-compile({ inline, escape_js_chunk/5 }).
-compile({ inline, escape_unicode/4 }).
-compile({ inline, escape_unicode_chunk/5 }).
-compile({ inline, handle_error/3 }).
-compile({ inline, maps_get/3 }).
-compile({ inline, maps_to_list/1 }).
% By default, encode_unhandled/2 will raise unsupported_type exception,
% so it is a function without a local return. Note that parse_opts/1
% is included because unhandled_encoder option has no local return.
-dialyzer({ no_return, parse_opts/1 }).
-dialyzer({ no_return, encode_unhandled/2 }).
-dialyzer( no_improper_lists ).
%% API functions
-export([ encode/2 ]).
-export([ parse_opts/1 ]).
-export([ get_nulls_option/1 ]).
-export([ get_binary_encoder_option/1 ]).
-export([ get_atom_encoder_option/1 ]).
-export([ get_integer_encoder_option/1 ]).
-export([ get_float_encoder_option/1 ]).
-export([ get_list_encoder_option/1 ]).
-export([ get_map_encoder_option/1 ]).
-export([ get_unhandled_encoder_option/1 ]).
-export([ get_escaper_option/1 ]).
-export([ get_error_handler_option/1 ]).
-export([ get_plugins_option/1 ]).
-export([ encode_parsed/2 ]).
-export([ encode_binary/2 ]).
-export([ encode_atom/2 ]).
-export([ encode_integer/2 ]).
-export([ encode_float/2 ]).
-export([ encode_list/2 ]).
-export([ encode_map/2 ]).
-export([ encode_unhandled/2 ]).
-export([ escape/2 ]).
-export([ escape_byte/1 ]).
-export([ escape_json/1 ]).
-export([ escape_html/1 ]).
-export([ escape_js/1 ]).
-export([ escape_unicode/1 ]).
-export([ throw_unsupported_type_error/1 ]).
-export([ handle_error/3 ]).
%% Types
-export_type([ input/0 ]).
-export_type([ options/0 ]).
-export_type([ parsed_options/0 ]).
-export_type([ result/0 ]).
-export_type([ encoder/1 ]).
-export_type([ escaper/1 ]).
-export_type([ error_handler/0 ]).
-export_type([ error_reason/0 ]).
-record(opts, { nulls :: list()
, binary_encoder :: encoder(binary())
, atom_encoder :: encoder(atom())
, integer_encoder :: encoder(integer())
, float_encoder :: encoder(float())
, list_encoder :: encoder(list())
, map_encoder :: encoder(map())
, unhandled_encoder :: encoder(term())
, escaper :: json
| html
| javascript
| unicode
| escaper(binary())
, error_handler :: error_handler()
, plugins :: [plugin()]
}).
-type input() :: term().
-type options() :: map().
-type parsed_options() :: #opts{}.
-type result() :: {ok, iolist()} | {error, error_reason()}.
-type encoder(Input) :: fun((Input, parsed_options()) -> iolist()).
-type escaper(Input) :: fun((Input, parsed_options()) -> iolist()).
-type error_class() :: error | exit | throw.
-type unsupported_type_error() :: {unsupported_type, Unsupported :: term()}.
-type invalid_byte_error() :: {invalid_byte, Byte :: byte(), Input :: binary()}.
-type error_reason() :: unsupported_type_error() | invalid_byte_error().
-type error_stacktrace() :: erlang:stacktrace().
-type error_handler() :: fun(( error_class()
, error_reason()
, error_stacktrace() ) -> error_stacktrace()).
-type plugin() :: datetime
| inet
| pid
| port
| proplist
| reference
| timestamp
| drop_nulls
| module()
.
%% Macros
-define(min(X, Min), is_integer(X) andalso X >= Min).
-define(range(X, Min, Max), is_integer(X) andalso X >= Min andalso X =< Max).
-define(is_proplist_key(X), is_binary(X) orelse is_atom(X) orelse is_integer(X)).
-define(NON_PRINTABLE_LAST, 31).
-define(ONE_BYTE_LAST, 127).
-define(TWO_BYTE_LAST, 2_047).
-define(THREE_BYTE_LAST, 65_535).
%%%=====================================================================
%%% API functions
%%%=====================================================================
%%----------------------------------------------------------------------
%% @doc Generates a JSON from Erlang term.
%%
%% @param Term :: {@link euneus_encoder:input()}.
%% @param Opts :: {@link euneus_encoder:options()}.
%%
%% @returns {@link euneus_encoder:result()}.
%%
%% @end
%%----------------------------------------------------------------------
-spec encode(input(), options()) -> result().
encode(Term, Opts) ->
encode_parsed(Term, parse_opts(Opts)).
%%----------------------------------------------------------------------
%% @doc Parses {@link euneus_encoder:options()} to {@link euneus_encoder:parsed_options()}.
%%
%% The parsed map can be expanded in compile time or stored to be
%% reused, avoiding parsing the options in every encoding.
%%
%% @end
%%
%% NOTE: The explicit call of functions wrapped in another function is
%% required for the inline optimization.
%%
%% @param Opts :: {@link euneus_encoder:options()}.
%%
%% @returns {@link euneus_encoder:parsed_options()}.
%%
%% @end
%%----------------------------------------------------------------------
-spec parse_opts(options()) -> parsed_options().
parse_opts(Opts) ->
#opts{
nulls = maps_get(nulls, Opts, [undefined]),
binary_encoder = maps_get(binary_encoder, Opts, fun (X, O) ->
escape(X, O)
end),
atom_encoder = maps_get(atom_encoder, Opts, fun (X, O) ->
encode_atom(X, O)
end),
integer_encoder = maps_get(integer_encoder, Opts, fun (X, O) ->
encode_integer(X, O)
end),
float_encoder = maps_get(float_encoder, Opts, fun (X, O) ->
encode_float(X, O)
end),
list_encoder = maps_get(list_encoder, Opts, fun (X, O) ->
encode_list(X, O)
end),
map_encoder = maps_get(map_encoder, Opts, fun (X, O) ->
encode_map(X, O)
end),
unhandled_encoder = maps_get(unhandled_encoder, Opts, fun (X, O) ->
encode_unhandled(X, O)
end),
escaper =
case maps_get(escaper, Opts, json) of
json ->
fun(X, _O) -> [$", escape_json(X, [], X, 0), $"] end;
html ->
fun(X, _O) -> [$", escape_html(X, [], X, 0), $"] end;
javascript ->
fun(X, _O) -> [$", escape_js(X, [], X, 0), $"] end;
unicode ->
fun(X, _O) -> [$", escape_unicode(X, [], X, 0), $"] end;
Fun when is_function(Fun, 2) ->
Fun
end,
error_handler = maps_get(error_handler, Opts, fun(C, R, S) ->
handle_error(C, R, S)
end),
plugins = maps_get(plugins, Opts, [])
}.
%%%---------------------------------------------------------------------
%%% Options
%%%---------------------------------------------------------------------
get_nulls_option(#opts{nulls = Nulls}) ->
Nulls.
get_binary_encoder_option(#opts{binary_encoder = BinaryEncoder}) ->
BinaryEncoder.
get_atom_encoder_option(#opts{atom_encoder = AtomEncoder}) ->
AtomEncoder.
get_integer_encoder_option(#opts{integer_encoder = IntegerEncoder}) ->
IntegerEncoder.
get_float_encoder_option(#opts{float_encoder = FloatEncoder}) ->
FloatEncoder.
get_list_encoder_option(#opts{list_encoder = ListEncoder}) ->
ListEncoder.
get_map_encoder_option(#opts{map_encoder = MapEncoder}) ->
MapEncoder.
get_unhandled_encoder_option(#opts{unhandled_encoder = UnhandledEncoder}) ->
UnhandledEncoder.
get_escaper_option(#opts{escaper = Escaper}) ->
Escaper.
get_error_handler_option(#opts{error_handler = Handler}) ->
Handler.
get_plugins_option(#opts{plugins = Plugins}) ->
Plugins.
%%----------------------------------------------------------------------
%% @doc Generates a JSON from Erlang term.
%%
%% @param Term :: {@link euneus_encoder:input()}.
%% @param Opts :: {@link euneus_encoder:parsed_options()}.
%%
%% @returns {@link euneus_encoder:result()}.
%%
%% @see euneus_encoder:parse_opts/1
%%
%% @end
%%----------------------------------------------------------------------
-spec encode_parsed(input(), parsed_options()) -> result().
encode_parsed(Term, Opts) ->
try
{ok, value(Term, Opts)}
catch
Class:Reason:Stacktrace ->
Handle = Opts#opts.error_handler,
Handle(Class, Reason, Stacktrace)
end.
encode_binary(Bin, Opts) ->
escape(Bin, Opts).
encode_atom(true, _Opts) ->
<<"true">>;
encode_atom(false, _Opts) ->
<<"false">>;
encode_atom(Atom, #opts{nulls = Nulls} = Opts) ->
case lists:member(Atom, Nulls) of
true ->
<<"null">>;
false ->
escape(atom_to_binary(Atom, utf8), Opts)
end.
encode_integer(Int, _Opts) ->
integer_to_binary(Int).
encode_float(Float, _Opts) ->
float_to_binary(Float, [short]).
encode_list([H | T], Opts) ->
[$[, value(H, Opts), do_encode_list_loop(T, Opts)];
encode_list([], _Opts) ->
<<"[]">>.
do_encode_list_loop([], _Opts) ->
[$]];
do_encode_list_loop([H | T], Opts) ->
[$,, value(H, Opts) | do_encode_list_loop(T, Opts)].
encode_map(Map, Opts) ->
do_encode_map(maps_to_list(Map), Opts).
do_encode_map([{K, V} | T], Opts) ->
[${, key(K, Opts), $:, value(V, Opts) | do_encode_map_loop(T, Opts)];
do_encode_map([], _) ->
<<"{}">>.
do_encode_map_loop([], _Opts) ->
[$}];
do_encode_map_loop([{K, V} | T], Opts) ->
[$,, key(K, Opts), $:, value(V, Opts) | do_encode_map_loop(T, Opts)].
encode_unhandled(Term, _Opts) ->
throw_unsupported_type_error(Term).
escape(Bin, #opts{escaper = Escape} = Opts) ->
Escape(Bin, Opts).
escape_json(Bin) ->
escape_json(Bin, [], Bin, 0).
escape_json(Data, Acc, Input, Pos) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\"">>],
escape_json(Rest, Acc1, Input, Pos+1);
<<$\\/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\\">>],
escape_json(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Acc1 = [Acc | escape_byte(Byte)],
escape_json(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, 1);
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, 2);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, 3);
<<_Char/utf8, Rest/bitstring>> ->
escape_json_chunk(Rest, Acc, Input, Pos, 4);
<<>> ->
Acc;
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_json_chunk(Data, Acc, Input, Pos, Len) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\"">>]],
escape_json(Rest, Acc1, Input, Pos+Len+1);
<<$\\/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\\">>]],
escape_json(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, escape_byte(Byte)]],
escape_json(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, Len+1);
<<>> ->
case Acc =:= [] of
true ->
binary_part(Input, Pos, Len);
false ->
[Acc, binary_part(Input, Pos, Len)]
end;
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, Len+2);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_json_chunk(Rest, Acc, Input, Pos, Len+3);
<<_Char/utf8, Rest/bitstring>> ->
escape_json_chunk(Rest, Acc, Input, Pos, Len+4);
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_html(Bin) ->
escape_html(Bin, [], Bin, 0).
escape_html(Data, Acc, Input, Pos) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Acc1 = [Acc, <<"\\\"">>],
escape_html(Rest, Acc1, Input, Pos+1);
<<$\\/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\\">>],
escape_html(Rest, Acc1, Input, Pos+1);
<<$//integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\/">>],
escape_html(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte < 33 ->
Acc1 = [Acc, escape_byte(Byte)],
escape_html(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, 1);
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, 2);
<<8232/utf8, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\u2028">>],
escape_html(Rest, Acc1, Input, Pos+3);
<<8233/utf8, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\u2029">>],
escape_html(Rest, Acc1, Input, Pos+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, 3);
<<_Char/utf8, Rest/bitstring>> ->
escape_html_chunk(Rest, Acc, Input, Pos, 4);
<<>> ->
Acc;
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_html_chunk(Data, Acc, Input, Pos, Len) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc | [Part, <<"\\\"">>]],
escape_html(Rest, Acc2, Input, Pos+Len+1);
<<$\\/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc | [Part, <<"\\\\">>]],
escape_html(Rest, Acc2, Input, Pos+Len+1);
<<$//integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc | [Part, <<"\\/">>]],
escape_html(Rest, Acc2, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc, Part, escape_byte(Byte)],
escape_html(Rest, Acc2, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, Len+1);
<<>> ->
case Acc =:= [] of
true ->
binary_part(Input, Pos, Len);
false ->
[Acc, binary_part(Input, Pos, Len)]
end;
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, Len+2);
<<8232/utf8, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc | [Part, <<"\\u2028">>]],
escape_html(Rest, Acc2, Input, Pos+Len+3);
<<8233/utf8, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc2 = [Acc | [Part, <<"\\u2029">>]],
escape_html(Rest, Acc2, Input, Pos+Len+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_html_chunk(Rest, Acc, Input, Pos, Len+3);
<<_Char/utf8, Rest/bitstring>> ->
escape_html_chunk(Rest, Acc, Input, Pos, Len+4);
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_js(Bin) ->
escape_js(Bin, [], Bin, 0).
escape_js(Data, Acc, Input, Pos) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\"">>],
escape_js(Rest, Acc1, Input, Pos+1);
<<$\\/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\\">>],
escape_js(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Acc1 = [Acc | escape_byte(Byte)],
escape_js(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, 1);
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, 2);
<<8232/utf8, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\u2028">>],
escape_js(Rest, Acc1, Input, Pos+3);
<<8233/utf8, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\u2029">>],
escape_js(Rest, Acc1, Input, Pos+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, 3);
<<_Char/utf8, Rest/bitstring>> ->
escape_js_chunk(Rest, Acc, Input, Pos, 4);
<<>> ->
Acc;
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_js_chunk(Data, Acc, Input, Pos, Len) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\"">>]],
escape_js(Rest, Acc1, Input, Pos+Len+1);
<<$\\/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\\">>]],
escape_js(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, escape_byte(Byte)]],
escape_js(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, Len+1);
<<>> ->
case Acc =:= [] of
true ->
binary_part(Input, Pos, Len);
false ->
[Acc, binary_part(Input, Pos, Len)]
end;
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, Len+2);
<<8232/utf8, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u2028">>]],
escape_js(Rest, Acc1, Input, Pos+Len+3);
<<8233/utf8, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u2029">>]],
escape_js(Rest, Acc1, Input, Pos+Len+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
escape_js_chunk(Rest, Acc, Input, Pos, Len+3);
<<_Char/utf8, Rest/bitstring>> ->
escape_js_chunk(Rest, Acc, Input, Pos, Len+4);
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_unicode(Bin) ->
escape_unicode(Bin, [], Bin, 0).
escape_unicode(Data, Acc, Input, Pos) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\"">>],
escape_unicode(Rest, Acc1, Input, Pos+1);
<<$\\/integer, Rest/bitstring>> ->
Acc1 = [Acc | <<"\\\\">>],
escape_unicode(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Acc1 = [Acc | escape_byte(Byte)],
escape_unicode(Rest, Acc1, Input, Pos+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_unicode_chunk(Rest, Acc, Input, Pos, 1);
<<Char/utf8, Rest/bitstring>> when Char < 256 ->
Acc1 = [Acc | [<<"\\u00">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+2);
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
Acc1 = [Acc | [<<"\\u0">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+2);
<<Char/utf8, Rest/bitstring>> when Char < 4096 ->
Acc1 = [Acc | [<<"\\u0">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
Acc1 = [Acc | [<<"\\u">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+3);
<<Char0/utf8, Rest/bitstring>> ->
Char = Char0 - 65536,
Acc1 = [ Acc
| [ <<"\\uD">>
, integer_to_binary(2048 bor (Char bsr 10), 16)
, <<"\\uD">>
, integer_to_binary(3072 bor Char band 1023, 16) ]
],
escape_unicode(Rest, Acc1, Input, Pos+4);
<<>> ->
Acc;
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_unicode_chunk(Data, Acc, Input, Pos, Len) ->
case Data of
<<$"/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\"">>]],
escape_unicode(Rest, Acc1, Input, Pos+Len+1);
<<$\\/integer, Rest/bitstring>> ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\\\">>]],
escape_unicode(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?NON_PRINTABLE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, escape_byte(Byte)]],
escape_unicode(Rest, Acc1, Input, Pos+Len+1);
<<Byte/integer, Rest/bitstring>> when Byte =< ?ONE_BYTE_LAST ->
escape_unicode_chunk(Rest, Acc, Input, Pos, Len+1);
<<>> ->
case Acc =:= [] of
true ->
binary_part(Input, Pos, Len);
false ->
[Acc | binary_part(Input, Pos, Len)]
end;
<<Char/utf8, Rest/bitstring>> when Char < 256 ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u00">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+Len+2);
<<Char/utf8, Rest/bitstring>> when Char =< ?TWO_BYTE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u0">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+Len+2);
<<Char/utf8, Rest/bitstring>> when Char < 4096 ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u0">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+Len+3);
<<Char/utf8, Rest/bitstring>> when Char =< ?THREE_BYTE_LAST ->
Part = binary_part(Input, Pos, Len),
Acc1 = [Acc | [Part, <<"\\u">>, integer_to_binary(Char, 16)]],
escape_unicode(Rest, Acc1, Input, Pos+Len+3);
<<Char0/utf8, Rest/bitstring>> ->
Char = Char0 - 65536,
Part = binary_part(Input, Pos, Len),
Acc1 = [ Acc
| [ Part
, <<"\\uD">>
, integer_to_binary(2048 bor (Char bsr 10), 16)
, <<"\\uD">>
, integer_to_binary(3072 bor Char band 1023, 16) ]
],
escape_unicode(Rest, Acc1, Input, Pos+Len+4);
<<Byte/integer, _Rest/bitstring>> ->
throw_invalid_byte_error(Byte, Input)
end.
escape_byte(0) -> <<"\\u0000">>;
escape_byte(1) -> <<"\\u0001">>;
escape_byte(2) -> <<"\\u0002">>;
escape_byte(3) -> <<"\\u0003">>;
escape_byte(4) -> <<"\\u0004">>;
escape_byte(5) -> <<"\\u0005">>;
escape_byte(6) -> <<"\\u0006">>;
escape_byte(7) -> <<"\\u0007">>;
escape_byte($\b) -> <<"\\b">>;
escape_byte($\t) -> <<"\\t">>;
escape_byte($\n) -> <<"\\n">>;
escape_byte($\v) -> <<"\\u000B">>;
escape_byte($\f) -> <<"\\f">>;
escape_byte($\r) -> <<"\\r">>;
escape_byte(14) -> <<"\\u000E">>;
escape_byte(15) -> <<"\\u000F">>;
escape_byte(16) -> <<"\\u0010">>;
escape_byte(17) -> <<"\\u0011">>;
escape_byte(18) -> <<"\\u0012">>;
escape_byte(19) -> <<"\\u0013">>;
escape_byte(20) -> <<"\\u0014">>;
escape_byte(21) -> <<"\\u0015">>;
escape_byte(22) -> <<"\\u0016">>;
escape_byte(23) -> <<"\\u0017">>;
escape_byte(24) -> <<"\\u0018">>;
escape_byte(25) -> <<"\\u0019">>;
escape_byte(26) -> <<"\\u001A">>;
escape_byte($\e) -> <<"\\u001B">>;
escape_byte(28) -> <<"\\u001C">>;
escape_byte(29) -> <<"\\u001D">>;
escape_byte(30) -> <<"\\u001E">>;
escape_byte(31) -> <<"\\u001F">>;
escape_byte($\") -> <<"\\\"">>;
escape_byte($/) -> <<"\\/">>;
escape_byte($\\) -> <<"\\\\">>;
escape_byte(Byte) -> throw_invalid_byte_error(Byte, Byte).
throw_unsupported_type_error(Term) ->
throw({unsupported_type, Term}).
throw_invalid_byte_error(Byte, Input) ->
throw({invalid_byte, Byte, Input}).
handle_error(throw, Reason, _Stacktrace) ->
case Reason of
{unsupported_type, Unsupported} ->
{error, {unsupported_type, Unsupported}};
{invalid_byte, Byte0, Input} ->
Byte = <<"0x"/utf8, (integer_to_binary(Byte0, 16))/binary>>,
{error, {invalid_byte, Byte, Input}};
_ ->
{error, Reason}
end;
handle_error(Class, Reason, Stacktrace) ->
erlang:raise(Class, Reason, Stacktrace).
%%%=====================================================================
%%% Internal functions
%%%=====================================================================
key(Atom, #opts{binary_encoder = Encode} = Opts) when is_atom(Atom) ->
Encode(atom_to_binary(Atom, utf8), Opts);
key(Bin, #opts{binary_encoder = Encode} = Opts) when is_binary(Bin) ->
Encode(Bin, Opts);
key(Int, #opts{binary_encoder = Encode} = Opts) when is_integer(Int) ->
Encode(integer_to_binary(Int), Opts);
key(String, #opts{binary_encoder = Encode} = Opts) when is_list(String) ->
Encode(list_to_binary(String), Opts).
value(Term, #opts{plugins = Plugins} = Opts) ->
case plugins(Plugins, Term, Opts) of
next ->
encode_term(Term, Opts);
{halt, IOData} ->
IOData
end.
plugins([], _Term, _Opts) ->
next;
plugins([datetime | T], Term, Opts) ->
case Term of
{{YYYY,MM,DD},{H,M,S}}
when ?min(YYYY, 0), ?range(MM, 1, 12), ?range(DD, 1, 31)
, ?range(H, 0, 23), ?range(M, 0, 59), ?range(S, 0, 59) ->
DateTime = iolist_to_binary(io_lib:format(
"~4.10.0B-~2.10.0B-~2.10.0BT~2.10.0B:~2.10.0B:~2.10.0BZ",
[YYYY,MM,DD,H,M,S])
),
{halt, escape(DateTime, Opts)};
_ ->
plugins(T, Term, Opts)
end;
plugins([inet | T], Term, Opts) ->
case Term of
{_A,_B,_C,_D} ->
case inet_parse:ntoa(Term) of
{error, einval} ->
plugins(T, Term, Opts);
Ipv4 ->
{halt, escape(list_to_binary(Ipv4), Opts)}
end;
{_A,_B,_C,_D,_E,_F,_G,_H} ->
case inet_parse:ntoa(Term) of
{error, einval} ->
plugins(T, Term, Opts);
Ipv6 ->
{halt, escape(list_to_binary(Ipv6), Opts)}
end;
_ ->
plugins(T, Term, Opts)
end;
plugins([pid | T], Term, Opts) ->
case is_pid(Term) of
true ->
Pid = iolist_to_binary(pid_to_list(Term)),
{halt, escape(Pid, Opts)};
false ->
plugins(T, Term, Opts)
end;
plugins([port | T], Term, Opts) ->
case is_port(Term) of
true ->
Pid = iolist_to_binary(port_to_list(Term)),
{halt, escape(Pid, Opts)};
false ->
plugins(T, Term, Opts)
end;
plugins([proplist | T], Term, Opts) ->
case Term of
[{X, _} | _] = Proplist when ?is_proplist_key(X) ->
Map = case lists:member(drop_nulls, Opts#opts.plugins) of
true ->
drop_nulls(proplists:to_map(Proplist), Opts);
false ->
proplists:to_map(Proplist)
end,
Encode = Opts#opts.map_encoder,
{halt, Encode(Map, Opts)};
_ ->
plugins(T, Term, Opts)
end;
plugins([reference | T], Term, Opts) ->
case is_reference(Term) of
true ->
Ref = iolist_to_binary(ref_to_list(Term)),
{halt, escape(Ref, Opts)};
false ->
plugins(T, Term, Opts)
end;
plugins([timestamp | T], Term, Opts) ->
case Term of
{MegaSecs, Secs, MicroSecs} = Timestamp
when ?min(MegaSecs, 0), ?min(Secs, 0), ?min(MicroSecs, 0) ->
MilliSecs = MicroSecs div 1000,
{{YYYY,MM,DD},{H,M,S}} = calendar:now_to_datetime(Timestamp),
DateTime = iolist_to_binary(io_lib:format(
"~4.10.0B-~2.10.0B-~2.10.0BT~2.10.0B:~2.10.0B:~2.10.0B.~3.10.0BZ",
[YYYY,MM,DD,H,M,S,MilliSecs])
),
{halt, escape(DateTime, Opts)};
_ ->
plugins(T, Term, Opts)
end;
plugins([drop_nulls | T], Term, Opts) ->
case is_map(Term) of
true ->
Map = drop_nulls(Term, Opts),
Encode = Opts#opts.map_encoder,
{halt, Encode(Map, Opts)};
false ->
plugins(T, Term, Opts)
end;
plugins([Plugin | T], Term, Opts) when is_atom(Plugin) ->
case Plugin:encode(Term, Opts) of
next ->
plugins(T, Term, Opts);
{halt, IOData} when is_binary(IOData); is_list(IOData) ->
{halt, IOData}
end.
drop_nulls(Map0, Opts) ->
Nulls = euneus_encoder:get_nulls_option(Opts),
maps:filter(fun(_, V) -> not lists:member(V, Nulls) end, Map0).
encode_term(Bin, #opts{binary_encoder = Encode} = Opts) when is_binary(Bin) ->
Encode(Bin, Opts);
encode_term(Atom, #opts{atom_encoder = Encode} = Opts) when is_atom(Atom) ->
Encode(Atom, Opts);
encode_term(Int, #opts{integer_encoder = Encode} = Opts) when is_integer(Int) ->
Encode(Int, Opts);
encode_term(Float, #opts{float_encoder = Encode} = Opts) when is_float(Float) ->
Encode(Float, Opts);
encode_term(List, #opts{list_encoder = Encode} = Opts) when is_list(List) ->
Encode(List, Opts);
encode_term(Map, #opts{map_encoder = Encode} = Opts) when is_map(Map) ->
Encode(Map, Opts);
encode_term(Term, #opts{unhandled_encoder = Encode} = Opts) ->
Encode(Term, Opts).
%%%=====================================================================
%%% Support functions
%%%=====================================================================
maps_get(Key, Map, Default) ->
case Map of
#{Key := Value} -> Value;
#{} -> Default
end.
maps_to_list(Map) ->
do_maps_to_list(erts_internal:map_next(0, Map, [])).
do_maps_to_list([Iter, Map | Acc]) when is_integer(Iter) ->
do_maps_to_list(erts_internal:map_next(Iter, Map, Acc));
do_maps_to_list(Acc) ->
Acc.
%%%=====================================================================
%%% Eunit tests
%%%=====================================================================
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
encode_to_bin(Input, Opts) ->
case encode(Input, Opts) of
{ok, IOList} ->
{ok, iolist_to_binary(IOList)};
{error, Reason} ->
{error, Reason}
end.
encode_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{{ok, <<"true">>}, true, #{}},
{{ok, <<"\"foo\"">>}, foo, #{}},
{{ok, <<"\"foo\"">>}, <<"foo">>, #{}},
{{ok, <<"0">>}, 0, #{}},
{{ok, <<"123.456789">>}, 123.45678900, #{}},
{{ok, <<"[true,0,null]">>}, [true,0,undefined], #{}},
{{ok, <<"{\"foo\":\"bar\"}">>}, #{foo => bar}, #{}},
{{ok, <<"{\"0\":0}">>}, #{0 => 0}, #{}}
]].
datetime_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {error, {unsupported_type, {{1970,1,1},{0,0,0}}}}
, {{1970,1,1},{0,0,0}}
, #{}
},
{ {ok, <<"\"1970-01-01T00:00:00Z\"">>}
, {{1970,1,1},{0,0,0}}
, #{plugins => [datetime]}
}
]].
inet_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
% ipv4
{{error, {unsupported_type, {0,0,0,0}}}, {0,0,0,0}, #{} },
{{ok, <<"\"0.0.0.0\"">>}, {0,0,0,0}, #{plugins => [inet]}},
% ipv6
{{error, {unsupported_type, {0,0,0,0,0,0,0,0}}}, {0,0,0,0,0,0,0,0}, #{} },
{{ok, <<"\"::\"">>}, {0,0,0,0,0,0,0,0}, #{plugins => [inet]} },
{{ok, <<"\"::1\"">>}, {0,0,0,0,0,0,0,1}, #{plugins => [inet]}},
{ {ok, <<"\"::192.168.42.2\"">>}
, {0,0,0,0,0,0,(192 bsl 8) bor 168,(42 bsl 8) bor 2}
, #{plugins => [inet]}
},
{ {ok, <<"\"::ffff:192.168.42.2\"">>}
, {0,0,0,0,0,16#FFFF,(192 bsl 8) bor 168,(42 bsl 8) bor 2}
, #{plugins => [inet]}
},
{ {ok, <<"\"3ffe:b80:1f8d:2:204:acff:fe17:bf38\"">>}
, {16#3ffe,16#b80,16#1f8d,16#2,16#204,16#acff,16#fe17,16#bf38}
, #{plugins => [inet]}
},
{ {ok, <<"\"fe80::204:acff:fe17:bf38\"">>}
, {16#fe80,0,0,0,16#204,16#acff,16#fe17,16#bf38}
, #{plugins => [inet]}
}
]].
pid_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {error, {unsupported_type, list_to_pid("<0.92.0>")}}
, list_to_pid("<0.92.0>")
, #{}
},
{ {ok, <<"\"<0.92.0>\"">>}
, list_to_pid("<0.92.0>")
, #{plugins => [pid]}
}
]].
port_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {error, {unsupported_type, list_to_port("#Port<0.1>")}}
, list_to_port("#Port<0.1>")
, #{}
},
{ {ok, <<"\"#Port<0.1>\"">>}
, list_to_port("#Port<0.1>")
, #{plugins => [port]}
}
]].
proplist_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {error, {unsupported_type, {foo, bar}}}, [{foo, bar}], #{}},
{ {ok, <<"{\"foo\":\"bar\"}">>}, [{foo, bar}], #{plugins => [proplist]}}
]].
reference_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {error, {unsupported_type, list_to_ref("#Ref<0.314572725.1088159747.110918>")}}
, list_to_ref("#Ref<0.314572725.1088159747.110918>")
, #{}
},
{ {ok, <<"\"#Ref<0.314572725.1088159747.110918>\"">>}
, list_to_ref("#Ref<0.314572725.1088159747.110918>")
, #{plugins => [reference]}
}
]].
timestamp_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{{error, {unsupported_type, {0,0,0}}}, {0,0,0}, #{}},
{ {ok, <<"\"1970-01-01T00:00:00.000Z\"">>}
, {0,0,0}
, #{plugins => [timestamp]}
}
]].
drop_nulls_plugin_test() ->
[ ?assertEqual(Expect, encode_to_bin(Input, Opts))
|| {Expect, Input, Opts} <- [
{ {ok, <<"{\"a\":1}">>}
, #{a => 1, b => undefined}
, #{plugins => [drop_nulls]}
},
{ {ok, <<"{\"a\":1}">>}
, #{a => 1, b => undefined, c => foo}
, #{nulls => [undefined, foo], plugins => [drop_nulls]}
},
{ {ok, <<"{\"a\":1}">>}
, [{a, 1}, {b, undefined}, {c, foo}]
, #{nulls => [undefined, foo], plugins => [proplist, drop_nulls]}
}
]].
-endif.
