From 6797bf3ed7bbf77f6fd41bc00c8f378a032ce74e Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Wed, 10 Jul 2013 05:41:19 +0000 Subject: [PATCH] rename `explicit_end` to `stream` in prep for behavior change --- README.md | 6 +++--- src/jsx_config.erl | 14 +++++++------- src/jsx_config.hrl | 2 +- src/jsx_decoder.erl | 28 ++++++++++++++-------------- src/jsx_parser.erl | 4 ++-- 5 files changed, 27 insertions(+), 27 deletions(-) diff --git a/README.md b/README.md index ff4d670..81f8dda 100644 --- a/README.md +++ b/README.md @@ -231,7 +231,7 @@ consider the parsing complete if input is exhausted and the json text is not unambiguously incomplete. this is mostly relevant when parsing bare numbers like `<<"1234">>`. this could be a complete json integer or just the beginning of a json integer that is being parsed incrementally. jsx will treat it as a whole -integer. calling jsx with the [option](#options) `explicit_end` reverses this +integer. calling jsx with the [option](#options) `stream` reverses this behavior and never considers parsing complete until the `incomplete` function is called with the argument `end_stream` @@ -308,7 +308,7 @@ option() = replaced_bad_utf8 | dirty_strings | ignored_bad_escapes | relax - | explicit_end + | stream ``` jsx functions all take a common set of options. not all flags have meaning @@ -384,7 +384,7 @@ additional options beyond these. see string term. note that this overrides `ignored_bad_escapes`, `unescaped_jsonp` and `escaped_strings` -- `explicit_end` +- `stream` see [incomplete input](#incomplete-input) diff --git a/src/jsx_config.erl b/src/jsx_config.erl index 183dbbf..1cb4d33 100644 --- a/src/jsx_config.erl +++ b/src/jsx_config.erl @@ -44,8 +44,8 @@ parse_config([replaced_bad_utf8|Rest], Config) -> parse_config(Rest, Config#config{replaced_bad_utf8=true}); parse_config([escaped_forward_slashes|Rest], Config) -> parse_config(Rest, Config#config{escaped_forward_slashes=true}); -parse_config([explicit_end|Rest], Config) -> - parse_config(Rest, Config#config{explicit_end=true}); +parse_config([stream|Rest], Config) -> + parse_config(Rest, Config#config{stream=true}); parse_config([single_quoted_strings|Rest], Config) -> parse_config(Rest, Config#config{single_quoted_strings=true}); parse_config([unescaped_jsonp|Rest], Config) -> @@ -115,7 +115,7 @@ valid_flags() -> escaped_strings, dirty_strings, ignored_bad_escapes, - explicit_end, + stream, relax, error_handler, incomplete_handler, @@ -157,7 +157,7 @@ config_test_() -> #config{ replaced_bad_utf8=true, escaped_forward_slashes=true, - explicit_end=true, + stream=true, single_quoted_strings=true, unescaped_jsonp=true, comments=true, @@ -167,7 +167,7 @@ config_test_() -> parse_config([ replaced_bad_utf8, escaped_forward_slashes, - explicit_end, + stream, single_quoted_strings, unescaped_jsonp, comments, @@ -246,13 +246,13 @@ config_to_list_test_() -> comments, dirty_strings, ignored_bad_escapes, - explicit_end + stream ], config_to_list( #config{ replaced_bad_utf8=true, escaped_forward_slashes=true, - explicit_end=true, + stream=true, single_quoted_strings=true, unescaped_jsonp=true, comments=true, diff --git a/src/jsx_config.hrl b/src/jsx_config.hrl index 502f103..09ebce6 100644 --- a/src/jsx_config.hrl +++ b/src/jsx_config.hrl @@ -7,7 +7,7 @@ escaped_strings = false, dirty_strings = false, ignored_bad_escapes = false, - explicit_end = false, + stream = false, error_handler = false, incomplete_handler = false }). \ No newline at end of file diff --git a/src/jsx_decoder.erl b/src/jsx_decoder.erl index 18ce26a..f5d09c7 100644 --- a/src/jsx_decoder.erl +++ b/src/jsx_decoder.erl @@ -145,7 +145,7 @@ incomplete(State, Rest, Handler, Acc, Stack, Config=#config{incomplete_handler=f {incomplete, fun(Stream) when is_binary(Stream) -> resume(<>, State, Handler, Acc, Stack, Config); (end_stream) -> - case resume(<>, State, Handler, Acc, Stack, Config#config{explicit_end=false}) of + case resume(<>, State, Handler, Acc, Stack, Config#config{stream=false}) of {incomplete, _} -> ?error(State, Rest, Handler, Acc, Stack, Config); Else -> Else end @@ -748,7 +748,7 @@ zero(<>, Handler, Acc, Stack, Config) -> decimal(Rest, Handler, acc_seq(Acc, ?decimalpoint), Stack, Config); zero(<>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E -> e(Rest, Handler, acc_seq(Acc, ".0e"), Stack, Config); -zero(<<>>, Handler, Acc, [], Config=#config{explicit_end=false}) -> +zero(<<>>, Handler, Acc, [], Config=#config{stream=false}) -> finish_number(<<>>, Handler, {zero, Acc}, [], Config); zero(<<>>, Handler, Acc, Stack, Config) -> incomplete(value, (end_seq(Acc)), Handler, Stack, Config); @@ -806,7 +806,7 @@ exp(Bin, Handler, Acc, Stack, Config) -> finish_number(Bin, Handler, {exp, Acc}, Stack, Config). -finish_number(Rest, Handler, Acc, [], Config=#config{explicit_end=false}) -> +finish_number(Rest, Handler, Acc, [], Config=#config{stream=false}) -> maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), [], Config); finish_number(<>, Handler, Acc, [object|Stack], Config) -> maybe_done(Rest, handle_event([format_number(Acc), end_object], Handler, Config), Stack, Config); @@ -901,7 +901,7 @@ comment(<<_/utf8, Rest/binary>>, Handler, Resume, Stack, Config) -> comment(Rest, Handler, Resume, Stack, Config); comment(<<_, Rest/binary>>, Handler, Resume, Stack, Config=#config{replaced_bad_utf8=true}) -> comment(Rest, Handler, Resume, Stack, Config); -comment(<<>>, Handler, done, [Comment], Config=#config{explicit_end=false}) +comment(<<>>, Handler, done, [Comment], Config=#config{stream=false}) when Comment == comment; Comment == multicomment -> resume(<<>>, done, Handler, unused, [], Config); comment(<<>>, Handler, Resume, Stack, Config) -> @@ -942,7 +942,7 @@ done(<>, Handler, Stack, Config=#config{comments=t comment(Rest, Handler, done, [multicomment|Stack], Config); done(<>, Handler, Stack, Config=#config{comments=true}) -> incomplete(done, <>, Handler, Stack, Config); -done(<<>>, {Handler, State}, [], Config=#config{explicit_end=true}) -> +done(<<>>, {Handler, State}, [], Config=#config{stream=true}) -> incomplete(done, <<>>, {Handler, State}, [], Config); done(<<>>, {_Handler, State}, [], _Config) -> State; done(Bin, Handler, Stack, Config) -> ?error(done, Bin, Handler, Stack, Config). @@ -968,7 +968,7 @@ decode(JSON, Config) -> Incremental = try Final = lists:foldl( fun(Byte, Decoder) -> {incomplete, F} = Decoder(Byte), F end, - decoder(jsx, [], [explicit_end] ++ Config), + decoder(jsx, [], [stream] ++ Config), json_to_bytes(JSON) ), Final(end_stream) @@ -1931,19 +1931,19 @@ error_test_() -> )}, {"zero error", ?_assertError( badarg, - Decode(<<"0"/utf8, 0>>, [explicit_end]) + Decode(<<"0"/utf8, 0>>, [stream]) )}, {"integer error", ?_assertError( badarg, - Decode(<<"1"/utf8, 0>>, [explicit_end]) + Decode(<<"1"/utf8, 0>>, [stream]) )}, {"decimal error", ?_assertError( badarg, - Decode(<<"1.0"/utf8, 0>>, [explicit_end]) + Decode(<<"1.0"/utf8, 0>>, [stream]) )}, {"exp error", ?_assertError( badarg, - Decode(<<"1.0e1"/utf8, 0>>, [explicit_end]) + Decode(<<"1.0e1"/utf8, 0>>, [stream]) )}, {"e error", ?_assertError( badarg, @@ -2026,19 +2026,19 @@ custom_error_handler_test_() -> )}, {"zero error", ?_assertEqual( {value, <<"0"/utf8, 0>>}, - Decode(<<"0"/utf8, 0>>, [explicit_end, {error_handler, Error}]) + Decode(<<"0"/utf8, 0>>, [stream, {error_handler, Error}]) )}, {"integer error", ?_assertEqual( {integer, <<0>>}, - Decode(<<"1"/utf8, 0>>, [explicit_end, {error_handler, Error}]) + Decode(<<"1"/utf8, 0>>, [stream, {error_handler, Error}]) )}, {"decimal error", ?_assertEqual( {decimal, <<0>>}, - Decode(<<"1.0"/utf8, 0>>, [explicit_end, {error_handler, Error}]) + Decode(<<"1.0"/utf8, 0>>, [stream, {error_handler, Error}]) )}, {"exp error", ?_assertEqual( {exp, <<0>>}, - Decode(<<"1.0e1"/utf8, 0>>, [explicit_end, {error_handler, Error}]) + Decode(<<"1.0e1"/utf8, 0>>, [stream, {error_handler, Error}]) )}, {"e error", ?_assertEqual( {decimal, <<$e, 0>>}, diff --git a/src/jsx_parser.erl b/src/jsx_parser.erl index f327bab..099b71e 100644 --- a/src/jsx_parser.erl +++ b/src/jsx_parser.erl @@ -169,7 +169,7 @@ maybe_done(BadTokens, Handler, Stack, Config) when is_list(BadTokens) -> maybe_done(Token, Handler, Stack, Config) -> maybe_done([Token], Handler, Stack, Config). -done([], Handler, [], Config=#config{explicit_end=true}) -> +done([], Handler, [], Config=#config{stream=true}) -> incomplete(done, Handler, [], Config); done(Tokens, Handler, [], Config) when Tokens == [end_json]; Tokens == [] -> {_, State} = handle_event(end_json, Handler, Config), @@ -617,7 +617,7 @@ parse(Events, Config) -> Incremental = try Final = lists:foldl( fun(Event, Parser) -> {incomplete, F} = Parser(Event), F end, - parser(jsx, [], [explicit_end] ++ Config), + parser(jsx, [], [stream] ++ Config), lists:map(fun(X) -> [X] end, Events) ), Final(end_stream)