umgeher/jsx
0
Fork 0
Code Issues Pull requests Activity

remove pre_encode support

Browse source
This commit is contained in:
alisdair sullivan 2013-03-11 01:13:01 -07:00
parent 0238916472
commit 07d84e25d0
3 changed files with 10 additions and 175 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/jsx_config.erl
View file

@ -65,11 +65,6 @@ parse_config([relax|Rest], Config) ->
comments = true,
ignored_bad_escapes = true
});
parse_config([{pre_encode, Encoder}|Rest] = Options, Config) when is_function(Encoder, 1) ->
case Config#config.pre_encode of
false -> parse_config(Rest, Config#config{pre_encode=Encoder})
; _ -> erlang:error(badarg, [Options, Config])
end;
parse_config([{error_handler, ErrorHandler}|Rest] = Options, Config) when is_function(ErrorHandler, 3) ->
case Config#config.error_handler of
false -> parse_config(Rest, Config#config{error_handler=ErrorHandler})
@ -81,11 +76,6 @@ parse_config([{incomplete_handler, IncompleteHandler}|Rest] = Options, Config) w
; _ -> erlang:error(badarg, [Options, Config])
end;
%% deprecated flags
parse_config([{pre_encoder, Encoder}|Rest] = Options, Config) when is_function(Encoder, 1) ->
case Config#config.pre_encode of
false -> parse_config(Rest, Config#config{pre_encode=Encoder})
; _ -> erlang:error(badarg, [Options, Config])
end;
parse_config([loose_unicode|Rest], Config) ->
parse_config(Rest, Config#config{replaced_bad_utf8=true});
parse_config([escape_forward_slash|Rest], Config) ->
@ -104,8 +94,7 @@ parse_config(Options, Config) ->
config_to_list(Config) ->
lists:map(
fun ({pre_encode, F}) -> {pre_encode, F};
({error_handler, F}) -> {error_handler, F};
fun ({error_handler, F}) -> {error_handler, F};
({incomplete_handler, F}) -> {incomplete_handler, F};
({Key, true}) -> Key
end,
@ -128,11 +117,9 @@ valid_flags() ->
ignored_bad_escapes,
explicit_end,
relax,
pre_encode,
error_handler,
incomplete_handler,
%% deprecated flags
pre_encoder, %% pre_encode
loose_unicode, %% replaced_bad_utf8
escape_forward_slash, %% escaped_forward_slashes
single_quotes, %% single_quoted_strings
@ -202,7 +189,6 @@ config_test_() ->
},
{"deprecated flags", ?_assertEqual(
#config{
pre_encode=fun lists:length/1,
replaced_bad_utf8=true,
escaped_forward_slashes=true,
single_quoted_strings=true,
@ -211,7 +197,6 @@ config_test_() ->
ignored_bad_escapes=true
},
parse_config([
{pre_encoder, fun lists:length/1},
loose_unicode,
escape_forward_slash,
single_quotes,
@ -220,17 +205,6 @@ config_test_() ->
ignore_bad_escapes
])
)},
{"pre_encode flag", ?_assertEqual(
#config{pre_encode=fun lists:length/1},
parse_config([{pre_encode, fun lists:length/1}])
)},
{"two pre_encoders defined", ?_assertError(
badarg,
parse_config([
{pre_encode, fun(_) -> true end},
{pre_encode, fun(_) -> false end}
])
)},
{"error_handler flag", ?_assertEqual(
#config{error_handler=fun ?MODULE:fake_error_handler/3},
parse_config([{error_handler, fun ?MODULE:fake_error_handler/3}])
@ -287,10 +261,6 @@ config_to_list_test_() ->
}
)
)},
{"pre_encode", ?_assertEqual(
[{pre_encode, fun lists:length/1}],
config_to_list(#config{pre_encode=fun lists:length/1})
)},
{"error handler", ?_assertEqual(
[{error_handler, fun ?MODULE:fake_error_handler/3}],
config_to_list(#config{error_handler=fun ?MODULE:fake_error_handler/3})

1
src/jsx_config.hrl
View file

@ -8,7 +8,6 @@
dirty_strings = false,
ignored_bad_escapes = false,
explicit_end = false,
pre_encode = false,
error_handler = false,
incomplete_handler = false
}).

152
src/jsx_encoder.erl
View file

@ -52,7 +52,7 @@ encoder(Handler, State, Config) ->
start(Term, {Handler, State}, Config) ->
try Handler:handle_event(end_json, value(pre_encode(Term, Config), {Handler, State}, Config))
try Handler:handle_event(end_json, value(Term, {Handler, State}, Config))
catch
throw:Error -> Error;
Type:Value -> erlang:Type(Value)
@ -77,23 +77,16 @@ value(List, Handler, Config) when is_list(List) ->
value(Term, Handler, Config) -> ?error(value, Term, Handler, Config).
list_or_object([Term|Rest], {Handler, State}, Config) ->
case pre_encode(Term, Config) of
{K, V} when is_atom(K); is_binary(K) ->
object([{K, V}|Rest], {Handler, Handler:handle_event(start_object, State)}, Config)
; T ->
list([T|Rest], {Handler, Handler:handle_event(start_array, State)}, Config)
end.
list_or_object([{K, V}|Rest], {Handler, State}, Config) when is_atom(K); is_binary(K) ->
object([{K, V}|Rest], {Handler, Handler:handle_event(start_object, State)}, Config);
list_or_object(Terms, {Handler, State}, Config) when is_list(Terms) ->
list(Terms, {Handler, Handler:handle_event(start_array, State)}, Config).
object([{Key, Value}, Next|Rest], {Handler, State}, Config) when is_atom(Key); is_binary(Key) ->
V = pre_encode(Value, Config),
object(
[pre_encode(Next, Config)|Rest],
{
Handler,
object([Next|Rest], {Handler,
value(
V,
Value,
{Handler, Handler:handle_event({key, clean_string(fix_key(Key), {Handler, State}, Config)}, State)},
Config
)
@ -106,7 +99,7 @@ object([{Key, Value}], {Handler, State}, Config) when is_atom(Key); is_binary(Ke
{
Handler,
value(
pre_encode(Value, Config),
Value,
{Handler, Handler:handle_event({key, clean_string(fix_key(Key), {Handler, State}, Config)}, State)},
Config
)
@ -118,14 +111,11 @@ object(Term, Handler, Config) -> ?error(object, Term, Handler, Config).
list([Value, Next|Rest], {Handler, State}, Config) ->
list([pre_encode(Next, Config)|Rest], {Handler, value(Value, {Handler, State}, Config)}, Config);
list([Next|Rest], {Handler, value(Value, {Handler, State}, Config)}, Config);
list([Value], {Handler, State}, Config) ->
list([], {Handler, value(Value, {Handler, State}, Config)}, Config);
list([], {Handler, State}, _Config) -> Handler:handle_event(end_array, State).
pre_encode(Value, #config{pre_encode=false}) -> Value;
pre_encode(Value, Config) -> (Config#config.pre_encode)(Value).
fix_key(Key) when is_atom(Key) -> fix_key(atom_to_binary(Key, utf8));
fix_key(Key) when is_binary(Key) -> Key.
@ -160,130 +150,6 @@ encode_test_() ->
encode(Term, Config) -> start(Term, {jsx, []}, jsx_config:parse_config(Config)).
pre_encoders_test_() ->
Term = [
{<<"object">>, [
{<<"literals">>, [true, false, null]},
{<<"strings">>, [<<"foo">>, <<"bar">>, <<"baz">>]},
{<<"numbers">>, [1, 1.0, 1.0e0]}
]}
],
[
{"no pre encode", ?_assertEqual(
[
start_object,
{key, <<"object">>}, start_object,
{key, <<"literals">>}, start_array,
{literal, true}, {literal, false}, {literal, null},
end_array,
{key, <<"strings">>}, start_array,
{string, <<"foo">>}, {string, <<"bar">>}, {string, <<"baz">>},
end_array,
{key, <<"numbers">>}, start_array,
{integer, 1}, {float, 1.0}, {float, 1.0},
end_array,
end_object,
end_object,
end_json
],
encode(Term, [])
)},
{"replace lists with empty lists", ?_assertEqual(
[
start_object,
{key, <<"object">>}, start_object,
{key, <<"literals">>}, start_array, end_array,
{key, <<"strings">>}, start_array, end_array,
{key, <<"numbers">>}, start_array, end_array,
end_object,
end_object,
end_json
],
encode(Term, [{pre_encode, fun(V) -> case V of [{_,_}|_] -> V; [{}] -> V; V when is_list(V) -> []; _ -> V end end}])
)},
{"replace objects with empty objects", ?_assertEqual(
[
start_object,
end_object,
end_json
],
encode(Term, [{pre_encode, fun(V) -> case V of [{_,_}|_] -> [{}]; _ -> V end end}])
)},
{"replace all non-list and non_tuple values with false", ?_assertEqual(
[
start_object,
{key, <<"object">>}, start_object,
{key, <<"literals">>}, start_array,
{literal, false}, {literal, false}, {literal, false},
end_array,
{key, <<"strings">>}, start_array,
{literal, false}, {literal, false}, {literal, false},
end_array,
{key, <<"numbers">>}, start_array,
{literal, false}, {literal, false}, {literal, false},
end_array,
end_object,
end_object,
end_json
],
encode(Term, [{pre_encode, fun(V) when is_list(V); is_tuple(V) -> V; (_) -> false end}])
)},
{"replace all atoms with atom_to_list", ?_assertEqual(
[
start_object,
{key, <<"object">>}, start_object,
{key, <<"literals">>}, start_array,
{string, <<"true">>}, {string, <<"false">>}, {string, <<"null">>},
end_array,
{key, <<"strings">>}, start_array,
{string, <<"foo">>}, {string, <<"bar">>}, {string, <<"baz">>},
end_array,
{key, <<"numbers">>}, start_array,
{integer, 1}, {float, 1.0}, {float, 1.0},
end_array,
end_object,
end_object,
end_json
],
encode(Term, [{pre_encode, fun(V) when is_atom(V) -> unicode:characters_to_binary(atom_to_list(V)); (V) -> V end}])
)},
{"pre_encode tuple", ?_assertEqual(
[
start_array,
{integer, 1}, {integer, 2}, {integer, 3},
end_array,
end_json
],
encode({1, 2, 3}, [{pre_encode, fun(Tuple) when is_tuple(Tuple) -> tuple_to_list(Tuple); (V) -> V end}])
)},
{"pre_encode 2-tuples", ?_assertEqual(
[
start_object,
{key, <<"two">>}, {integer, 2}, {key, <<"three">>}, {integer, 3},
end_object,
end_json
],
encode([{two, 1}, {three, 2}], [{pre_encode, fun({K, V}) -> {K, V + 1}; (V) -> V end}])
)},
{"pre_encode one field record", ?_assertEqual(
[
start_object,
{key, <<"bar">>}, {literal, false},
end_object,
end_json
],
encode([{foo, bar}], [{pre_encode, fun({foo, V}) -> {V, undefined}; (undefined) -> false; (V) -> V end}])
)},
{"pre_encode list", ?_assertEqual(
[
start_array,
{integer, 2}, {integer, 3}, {integer, 4},
end_array,
end_json
],
encode([1,2,3], [{pre_encode, fun(X) when is_integer(X) -> X + 1; (V) -> V end}])
)}
].
error_test_() ->
[