jsonpull

% @doc These functions will read a value or error out immediately, with useful errorinfo applied on top.

%

% TODO: keep? remove?

-module(jsonpull_expect).

-export([

    null/1,

    boolean/1,

    string/1,

    iolist/1,

    existing_atom/1,

    number/1,

    integer/1,

    float/1,

    array/1,

    element/1,

    object/1,

    key/1

]).

-export([

    format_error/2

]).

-define(WRAP(X),

X(Bin) when is_binary(Bin) ->

    case jsonpull:X(Bin) of

        {ok, V} -> V;

        {error, E} -> erlang:error(E, [Bin], [{error_info, #{cause => E}}])

    end;

X(Arg) -> erlang:error(badarg, [Arg], [{error_info, #{cause => not_binary}}])).

-spec null(JSON :: binary()) -> {null, Rest :: binary()}.
?WRAP(null).

-spec boolean(JSON :: binary()) -> {boolean, Rest :: binary()}.
?WRAP(boolean).

-spec string(JSON :: binary()) -> {binary(), Rest :: binary()}.
?WRAP(string).

-spec iolist(JSON :: binary()) -> {iolist(), Rest :: binary()}.
?WRAP(iolist).

-spec existing_atom(JSON :: binary()) -> {atom(), Rest :: binary()}.
?WRAP(existing_atom).

-spec number(JSON :: binary()) -> {binary(), Rest :: binary()}.
?WRAP(number).

-spec integer(JSON :: binary()) -> {integer(), Rest :: binary()}.
?WRAP(integer).

-spec float(JSON :: binary()) -> {float(), Rest :: binary()}.
?WRAP(float).

-spec array(JSON :: binary()) -> {begin_array, Rest :: binary()}.
?WRAP(array).

-spec element(JSON :: binary()) -> {element | end_array, Rest :: binary()}.
?WRAP(element).

-spec object(JSON :: binary()) -> {begin_object, Rest :: binary()}.
?WRAP(object).

-spec key(JSON :: binary()) -> {binary() | end_object, Rest :: binary()}.
?WRAP(key).

% @private

format_error(system_limit, _) -> #{};
format_error(_, [{_, F, As, Info}|_]) ->
    ErrorInfoMap = proplists:get_value(error_info, Info, #{}),
    Cause = maps:get(cause, ErrorInfoMap, none),
    do_format_error(F, As, Cause).

do_format_error(_, _, not_binary) ->
    #{ 1 => "should be a binary" };

do_format_error(_, _, not_null) ->
    #{ reason => "the next value is not a null" };

do_format_error(_, _, not_boolean) ->
    #{ reason => "the next value is not a boolean" };

do_format_error(_, _, not_string) ->
    #{ reason => "the next value is not a string" };
do_format_error(_, _, unterminated_string) ->
    #{ reason => "the string is missing one or more terminators" };
do_format_error(_, _, invalid_escape_sequence) ->
    #{ reason => "the string contains an invalid escape sequence" };

do_format_error(_, _, not_existing_atom) ->
    #{ reason => "not an already existing atom" };

do_format_error(_, _, not_number) ->
    #{ reason => "the next value is not a number" };

do_format_error(_, _, not_integer) ->
    #{ reason => "the next value is not an integer" };

do_format_error(_, _, not_float) ->
    #{ reason => "the next value is not a float" };

do_format_error(_, _, not_array) ->
    #{ reason => "the next value is not an array" };

do_format_error(_, _, not_object) ->
    #{ reason => "the next value is not an object" };

do_format_error(_, _, missing_colon_after_key) ->
    #{ reason => "there is no : following the key" };
do_format_error(_, _, unterminated_key) ->
    #{ reason => "the key is missing one or more terminators" };
do_format_error(_, _, key_not_string) ->
    #{ reason => "the key is not a string" }.