rename explicit_end to stream in prep for behavior change

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)
 

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([stream|Rest], Config) ->
-    parse_config(Rest, Config#config{explicit_end=true});
+    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,

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
 }).

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(<<Rest/binary, Stream/binary>>, State, Handler, Acc, Stack, Config);
             (end_stream) ->
-                case resume(<<Rest/binary, ?space/utf8>>, State, Handler, Acc, Stack, Config#config{explicit_end=false}) of
+                case resume(<<Rest/binary, ?space/utf8>>, 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(<<?decimalpoint, Rest/binary>>, Handler, Acc, Stack, Config) ->
     decimal(Rest, Handler, acc_seq(Acc, ?decimalpoint), Stack, Config);
 zero(<<S, Rest/binary>>, 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(<<?end_object, Rest/binary>>, 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(<<?solidus, ?star, Rest/binary>>, Handler, Stack, Config=#config{comments=t
     comment(Rest, Handler, done, [multicomment|Stack], Config);
 done(<<?solidus>>, Handler, Stack, Config=#config{comments=true}) ->
     incomplete(done, <<?solidus>>, 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>>},

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)