From 6ff94d8e5fe7260401c410950aeb69c8a8eaac2e Mon Sep 17 00:00:00 2001
From: alisdair sullivan <alisdairsullivan@yahoo.ca>
Date: Wed, 21 Nov 2012 23:04:14 -0800
Subject: [PATCH] strip trailing whitespace

---
 src/jsx_decoder.erl | 86 ++++++++++++++++++++++-----------------------
 src/jsx_encoder.erl |  2 +-
 src/jsx_parser.erl  | 16 ++++-----
 src/jsx_to_json.erl | 14 ++++----
 src/jsx_to_term.erl | 10 +++---
 src/jsx_utils.erl   |  2 +-
 src/jsx_verify.erl  | 40 ++++++++++-----------
 7 files changed, 85 insertions(+), 85 deletions(-)

diff --git a/src/jsx_decoder.erl b/src/jsx_decoder.erl
index e42cff7..c3fe26b 100644
--- a/src/jsx_decoder.erl
+++ b/src/jsx_decoder.erl
@@ -76,7 +76,7 @@ decoder(Handler, State, Opts) ->
 %% some useful guards
 -define(is_hex(Symbol),
     (Symbol >= $a andalso Symbol =< $z);
-    (Symbol >= $A andalso Symbol =< $Z); 
+    (Symbol >= $A andalso Symbol =< $Z);
     (Symbol >= $0 andalso Symbol =< $9)
 ).
 
@@ -177,7 +177,7 @@ value(<<?start_object, Rest/binary>>, Handler, Stack, Opts) ->
     object(Rest, handle_event(start_object, Handler, Opts), [key|Stack], Opts);
 value(<<?start_array, Rest/binary>>, Handler, Stack, Opts) ->
     array(Rest, handle_event(start_array, Handler, Opts), [array|Stack], Opts);
-value(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) -> 
+value(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) ->
     value(Rest, Handler, Stack, Opts);
 value(<<?solidus, Rest/binary>>, Handler, Stack, Opts=#opts{comments=true}) ->
     comment(Rest, Handler, [value|Stack], Opts);
@@ -202,7 +202,7 @@ object(<<>>, Handler, Stack, Opts) ->
 object(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
 
-   
+
 array(<<?doublequote, Rest/binary>>, Handler, Stack, Opts) ->
     string(Rest, Handler, [?new_seq()|Stack], Opts);
 array(<<?singlequote, Rest/binary>>, Handler, Stack, Opts = #opts{single_quoted_strings=true}) ->
@@ -225,7 +225,7 @@ array(<<?start_array, Rest/binary>>, Handler, Stack, Opts) ->
     array(Rest, handle_event(start_array, Handler, Opts), [array|Stack], Opts);
 array(<<?end_array, Rest/binary>>, Handler, [array|Stack], Opts) ->
     maybe_done(Rest, handle_event(end_array, Handler, Opts), Stack, Opts);
-array(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) -> 
+array(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) ->
     array(Rest, Handler, Stack, Opts);
 array(<<?solidus, Rest/binary>>, Handler, Stack, Opts=#opts{comments=true}) ->
     comment(Rest, Handler, [array|Stack], Opts);
@@ -254,7 +254,7 @@ key(<<?singlequote, Rest/binary>>, Handler, Stack, Opts = #opts{single_quoted_st
 key(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) ->
     key(Rest, Handler, Stack, Opts);
 key(<<?solidus, Rest/binary>>, Handler, Stack, Opts=#opts{comments=true}) ->
-    comment(Rest, Handler, [key|Stack], Opts);       
+    comment(Rest, Handler, [key|Stack], Opts);
 key(<<>>, Handler, Stack, Opts) ->
     ?incomplete(key, <<>>, Handler, Stack, Opts);
 key(Bin, Handler, Stack, Opts) ->
@@ -270,7 +270,7 @@ key(Bin, Handler, Stack, Opts) ->
 partial_utf(<<>>) -> true;
 partial_utf(<<X>>) when X >= 16#c2, X =< 16#f4 -> true;
 partial_utf(<<X, Y>>) when X >= 16#e0, X =< 16#f4, Y >= 16#80, Y =< 16#bf -> true;
-partial_utf(<<X, Y, Z>>) 
+partial_utf(<<X, Y, Z>>)
         when X >= 16#f0, X =< 16#f4,
             Y >= 16#80, Y =< 16#bf,
             Z >= 16#80, Z =< 16#bf ->
@@ -537,7 +537,7 @@ string(<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Opts) ->
         ; false -> ?error([<<X/utf8, Rest/binary>>, Handler, [Acc|Stack], Opts])
     end;
 string(Bin, Handler, Stack, Opts) ->
-    case partial_utf(Bin) of 
+    case partial_utf(Bin) of
         true -> ?incomplete(string, Bin, Handler, Stack, Opts)
         ; false ->
             case Opts#opts.replaced_bad_utf8 of
@@ -546,7 +546,7 @@ string(Bin, Handler, Stack, Opts) ->
             end
     end.
 
-    
+
 %% we don't need to guard against partial utf here, because it's already taken
 %%   care of in string
 %% surrogates
@@ -580,7 +580,7 @@ strip_continuations(Rest, Handler, [0, Acc|Stack], Opts) ->
     string(Rest, Handler, [?acc_seq(Acc, 16#fffd)|Stack], Opts);
 strip_continuations(<<X, Rest/binary>>, Handler,  [N|Stack], Opts) when X >= 128, X =< 191 ->
     strip_continuations(Rest, Handler, [N - 1|Stack], Opts);
-%% incomplete    
+%% incomplete
 strip_continuations(<<>>, Handler, Stack, Opts) ->
     ?incomplete(strip_continuations, <<>>, Handler, Stack, Opts);
 %% not a continuation byte, dispatch back to string
@@ -616,7 +616,7 @@ escape(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
 
 
-%% this code is ugly and unfortunate, but so is json's handling of escaped 
+%% this code is ugly and unfortunate, but so is json's handling of escaped
 %%   unicode codepoint sequences.
 escaped_unicode(<<A, B, C, D, Rest/binary>>, Handler, [Acc|Stack], Opts)
         when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
@@ -650,7 +650,7 @@ is_partial_escape(_) -> false.
 low_surrogate(<<?rsolidus, $u, A, B, C, D, Rest/binary>>, Handler, [High, Acc|Stack], Opts)
         when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
     case erlang:list_to_integer([A, B, C, D], 16) of
-        X when X >= 16#dc00, X =< 16#dfff -> 
+        X when X >= 16#dc00, X =< 16#dfff ->
             Y = surrogate_to_codepoint(High, X),
             case (Y =< 16#d800 orelse Y >= 16#e000) of
                 true -> string(Rest, Handler, [?acc_seq(Acc, Y)|Stack], Opts)
@@ -677,7 +677,7 @@ low_surrogate(Bin, Handler, [High, Acc|Stack], Opts) ->
                 ; false -> ?error([Bin, Handler, [High, Acc|Stack], Opts])
             end
     end.
-        
+
 
 is_partial_low(<<?rsolidus, $u, A, B, C>>) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> true;
 is_partial_low(<<?rsolidus, $u, A, B>>) when ?is_hex(A), ?is_hex(B) -> true;
@@ -688,7 +688,7 @@ is_partial_low(<<>>) -> true;
 is_partial_low(_) -> false.
 
 
-%% stole this from the unicode spec    
+%% stole this from the unicode spec
 surrogate_to_codepoint(High, Low) ->
     (High - 16#d800) * 16#400 + (Low - 16#dc00) + 16#10000.
 
@@ -728,7 +728,7 @@ negative(<<$0, Rest/binary>>, Handler, [Acc|Stack], Opts) ->
     zero(Rest, Handler, ["0" ++ Acc|Stack], Opts);
 negative(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when ?is_nonzero(S) ->
     integer(Rest, Handler, [[S] ++ Acc|Stack], Opts);
-negative(<<>>, Handler, Stack, Opts) ->  
+negative(<<>>, Handler, Stack, Opts) ->
     ?incomplete(negative, <<>>, Handler, Stack, Opts);
 negative(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -747,7 +747,7 @@ zero(<<?decimalpoint, Rest/binary>>, Handler, [Acc|Stack], Opts) ->
 zero(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when ?is_whitespace(S) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 zero(<<?solidus, Rest/binary>>, Handler, [Acc|Stack], Opts=#opts{comments=true}) ->
-    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts);  
+    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts);
 zero(<<>>, Handler, [Acc|Stack], Opts = #opts{explicit_end=false}) ->
     maybe_done(<<>>, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 zero(<<>>, Handler, Stack, Opts) ->
@@ -775,7 +775,7 @@ integer(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when S =:= $e; S =:= $E
 integer(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when ?is_whitespace(S) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 integer(<<?solidus, Rest/binary>>, Handler, [Acc|Stack], Opts=#opts{comments=true}) ->
-    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts); 
+    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts);
 integer(<<>>, Handler, [Acc|Stack], Opts = #opts{explicit_end=false}) ->
     maybe_done(<<>>, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 integer(<<>>, Handler, Stack, Opts) ->
@@ -808,7 +808,7 @@ decimal(<<S, Rest/binary>>, Handler, [{Int, Frac}|Stack], Opts) when S =:= $e; S
 decimal(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when ?is_whitespace(S) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 decimal(<<?solidus, Rest/binary>>, Handler, [Acc|Stack], Opts=#opts{comments=true}) ->
-    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts); 
+    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts);
 decimal(<<>>, Handler, [Acc|Stack], Opts = #opts{explicit_end=false}) ->
     maybe_done(<<>>, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 decimal(<<>>, Handler, Stack, Opts) ->
@@ -818,10 +818,10 @@ decimal(Bin, Handler, Stack, Opts) ->
 
 
 e(<<S, Rest/binary>>, Handler, [{Int, Frac, Exp}|Stack], Opts) when S =:= ?zero; ?is_nonzero(S) ->
-    exp(Rest, Handler, [{Int, Frac, [S] ++ Exp}|Stack], Opts);   
+    exp(Rest, Handler, [{Int, Frac, [S] ++ Exp}|Stack], Opts);
 e(<<S, Rest/binary>>, Handler, [{Int, Frac, Exp}|Stack], Opts) when S =:= ?positive; S =:= ?negative ->
     ex(Rest, Handler, [{Int, Frac, [S] ++ Exp}|Stack], Opts);
-e(<<>>, Handler, Stack, Opts) ->  
+e(<<>>, Handler, Stack, Opts) ->
     ?incomplete(e, <<>>, Handler, Stack, Opts);
 e(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -829,7 +829,7 @@ e(Bin, Handler, Stack, Opts) ->
 
 ex(<<S, Rest/binary>>, Handler, [{Int, Frac, Exp}|Stack], Opts) when S =:= ?zero; ?is_nonzero(S) ->
     exp(Rest, Handler, [{Int, Frac, [S] ++ Exp}|Stack], Opts);
-ex(<<>>, Handler, Stack, Opts) ->  
+ex(<<>>, Handler, Stack, Opts) ->
     ?incomplete(ex, <<>>, Handler, Stack, Opts);
 ex(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -848,7 +848,7 @@ exp(<<?comma, Rest/binary>>, Handler, [Acc, array|Stack], Opts) ->
 exp(<<S, Rest/binary>>, Handler, [Acc|Stack], Opts) when ?is_whitespace(S) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 exp(<<?solidus, Rest/binary>>, Handler, [Acc|Stack], Opts=#opts{comments=true}) ->
-    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts); 
+    comment(Rest, handle_event(format_number(Acc), Handler, Opts), [maybe_done|Stack], Opts);
 exp(<<>>, Handler, [Acc|Stack], Opts = #opts{explicit_end=false}) ->
     maybe_done(<<>>, handle_event(format_number(Acc), Handler, Opts), Stack, Opts);
 exp(<<>>, Handler, Stack, Opts) ->
@@ -869,7 +869,7 @@ format_number({Int, Frac, Exp}) ->
 
 tr(<<$r, Rest/binary>>, Handler, Stack, Opts) ->
     tru(Rest, Handler, Stack, Opts);
-tr(<<>>, Handler, Stack, Opts) ->  
+tr(<<>>, Handler, Stack, Opts) ->
     ?incomplete(tr, <<>>, Handler, Stack, Opts);
 tr(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -877,7 +877,7 @@ tr(Bin, Handler, Stack, Opts) ->
 
 tru(<<$u, Rest/binary>>, Handler, Stack, Opts) ->
     true(Rest, Handler, Stack, Opts);
-tru(<<>>, Handler, Stack, Opts) ->  
+tru(<<>>, Handler, Stack, Opts) ->
     ?incomplete(tru, <<>>, Handler, Stack, Opts);
 tru(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -885,7 +885,7 @@ tru(Bin, Handler, Stack, Opts) ->
 
 true(<<$e, Rest/binary>>, Handler, Stack, Opts) ->
     maybe_done(Rest, handle_event({literal, true}, Handler, Opts), Stack, Opts);
-true(<<>>, Handler, Stack, Opts) ->  
+true(<<>>, Handler, Stack, Opts) ->
     ?incomplete(true, <<>>, Handler, Stack, Opts);
 true(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -893,31 +893,31 @@ true(Bin, Handler, Stack, Opts) ->
 
 fa(<<$a, Rest/binary>>, Handler, Stack, Opts) ->
     fal(Rest, Handler, Stack, Opts);
-fa(<<>>, Handler, Stack, Opts) ->  
+fa(<<>>, Handler, Stack, Opts) ->
     ?incomplete(fa, <<>>, Handler, Stack, Opts);
 fa(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
-    
+
 
 fal(<<$l, Rest/binary>>, Handler, Stack, Opts) ->
     fals(Rest, Handler, Stack, Opts);
-fal(<<>>, Handler, Stack, Opts) ->  
+fal(<<>>, Handler, Stack, Opts) ->
     ?incomplete(fal, <<>>, Handler, Stack, Opts);
 fal(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
-    
+
 
 fals(<<$s, Rest/binary>>, Handler, Stack, Opts) ->
     false(Rest, Handler, Stack, Opts);
-fals(<<>>, Handler, Stack, Opts) ->  
+fals(<<>>, Handler, Stack, Opts) ->
     ?incomplete(fals, <<>>, Handler, Stack, Opts);
 fals(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
-    
+
 
 false(<<$e, Rest/binary>>, Handler, Stack, Opts) ->
     maybe_done(Rest, handle_event({literal, false}, Handler, Opts), Stack, Opts);
-false(<<>>, Handler, Stack, Opts) ->  
+false(<<>>, Handler, Stack, Opts) ->
     ?incomplete(false, <<>>, Handler, Stack, Opts);
 false(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -925,7 +925,7 @@ false(Bin, Handler, Stack, Opts) ->
 
 nu(<<$u, Rest/binary>>, Handler, Stack, Opts) ->
     nul(Rest, Handler, Stack, Opts);
-nu(<<>>, Handler, Stack, Opts) ->  
+nu(<<>>, Handler, Stack, Opts) ->
     ?incomplete(nu, <<>>, Handler, Stack, Opts);
 nu(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -933,7 +933,7 @@ nu(Bin, Handler, Stack, Opts) ->
 
 nul(<<$l, Rest/binary>>, Handler, Stack, Opts) ->
     null(Rest, Handler, Stack, Opts);
-nul(<<>>, Handler, Stack, Opts) ->  
+nul(<<>>, Handler, Stack, Opts) ->
     ?incomplete(nul, <<>>, Handler, Stack, Opts);
 nul(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -941,7 +941,7 @@ nul(Bin, Handler, Stack, Opts) ->
 
 null(<<$l, Rest/binary>>, Handler, Stack, Opts) ->
     maybe_done(Rest, handle_event({literal, null}, Handler, Opts), Stack, Opts);
-null(<<>>, Handler, Stack, Opts) ->  
+null(<<>>, Handler, Stack, Opts) ->
     ?incomplete(null, <<>>, Handler, Stack, Opts);
 null(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -950,7 +950,7 @@ null(Bin, Handler, Stack, Opts) ->
 comment(<<?solidus, Rest/binary>>, Handler, Stack, Opts) ->
     single_comment(Rest, Handler, Stack, Opts);
 comment(<<?star, Rest/binary>>, Handler, Stack, Opts) ->
-    multi_comment(Rest, Handler, Stack, Opts); 
+    multi_comment(Rest, Handler, Stack, Opts);
 comment(<<>>, Handler, Stack, Opts) ->
     ?incomplete(comment, <<>>, Handler, Stack, Opts);
 comment(Bin, Handler, Stack, Opts) ->
@@ -962,7 +962,7 @@ single_comment(<<?newline, Rest/binary>>, Handler, Stack, Opts) ->
 single_comment(<<_/utf8, Rest/binary>>, Handler, Stack, Opts) ->
     single_comment(Rest, Handler, Stack, Opts);
 single_comment(<<>>, Handler, [done], Opts=#opts{explicit_end=false}) ->
-    end_comment(<<>>, Handler, [done], Opts);   
+    end_comment(<<>>, Handler, [done], Opts);
 single_comment(<<>>, Handler, Stack, Opts) ->
     ?incomplete(single_comment, <<>>, Handler, Stack, Opts);
 single_comment(Bin, Handler, Stack, Opts) ->
@@ -1015,7 +1015,7 @@ maybe_done(<<S, Rest/binary>>, Handler, Stack, Opts) when ?is_whitespace(S) ->
     maybe_done(Rest, Handler, Stack, Opts);
 maybe_done(<<?solidus, Rest/binary>>, Handler, Stack, Opts=#opts{comments=true}) ->
     comment(Rest, Handler, [maybe_done|Stack], Opts);
-maybe_done(<<>>, Handler, Stack, Opts) when length(Stack) > 0 -> 
+maybe_done(<<>>, Handler, Stack, Opts) when length(Stack) > 0 ->
     ?incomplete(maybe_done, <<>>, Handler, Stack, Opts);
 maybe_done(Bin, Handler, Stack, Opts) ->
     ?error([Bin, Handler, Stack, Opts]).
@@ -1114,7 +1114,7 @@ bad_utf8_test_() ->
         },
         {"all continuation bytes",
             ?_assert(is_bad(xcode(<<(list_to_binary(lists:seq(16#0080, 16#00bf)))/binary>>)))
-        },        
+        },
         {"all continuation bytes replaced",
             ?_assertEqual(
                 xcode(<<(list_to_binary(lists:seq(16#0080, 16#00bf)))/binary>>, [replaced_bad_utf8]),
@@ -1531,7 +1531,7 @@ reserved_test_() ->
         }
     ].
 
-    
+
 good_characters_test_() ->
     [
         {"acceptable codepoints",
@@ -1550,7 +1550,7 @@ good_characters_test_() ->
             ?_assert(check_good(good_extended()))
         }
     ].
-    
+
 
 check_bad(List) ->
     [] == lists:dropwhile(fun({_, {error, badarg}}) -> true ; (_) -> false end,
@@ -1559,7 +1559,7 @@ check_bad(List) ->
 
 
 check_replaced(List) ->
-    [] == lists:dropwhile(fun({_, [{string, <<16#fffd/utf8>>}|_]}) -> true ; (_) -> false 
+    [] == lists:dropwhile(fun({_, [{string, <<16#fffd/utf8>>}|_]}) -> true ; (_) -> false
         end,
         check(List, [replaced_bad_utf8], [])
     ).
@@ -1604,7 +1604,7 @@ good() -> [32, 33]
             ++ lists:seq(16#fdf0, 16#fffd).
 
 good_extended() -> [16#10000, 16#20000, 16#30000, 16#40000, 16#50000,
-        16#60000, 16#70000, 16#80000, 16#90000, 16#a0000, 
+        16#60000, 16#70000, 16#80000, 16#90000, 16#a0000,
         16#b0000, 16#c0000, 16#d0000, 16#e0000, 16#f0000
     ] ++ lists:seq(16#100000, 16#10fffd).
 
@@ -1613,7 +1613,7 @@ good_extended() -> [16#10000, 16#20000, 16#30000, 16#40000, 16#50000,
 to_fake_utf(N, utf8) when N < 16#0080 -> <<34/utf8, N:8, 34/utf8>>;
 to_fake_utf(N, utf8) when N < 16#0800 ->
     <<0:5, Y:5, X:6>> = <<N:16>>,
-    <<34/utf8, 2#110:3, Y:5, 2#10:2, X:6, 34/utf8>>; 
+    <<34/utf8, 2#110:3, Y:5, 2#10:2, X:6, 34/utf8>>;
 to_fake_utf(N, utf8) when N < 16#10000 ->
     <<Z:4, Y:6, X:6>> = <<N:16>>,
     <<34/utf8, 2#1110:4, Z:4, 2#10:2, Y:6, 2#10:2, X:6, 34/utf8>>;
diff --git a/src/jsx_encoder.erl b/src/jsx_encoder.erl
index a172f55..a748779 100644
--- a/src/jsx_encoder.erl
+++ b/src/jsx_encoder.erl
@@ -899,7 +899,7 @@ pre_encoders_test_() ->
                 start_array,
                     {integer, 1}, {integer, 2}, {integer, 3},
                 end_array,
-                end_json 
+                end_json
             ]
         )},
         {"pre_encode 2-tuples", ?_assertEqual(
diff --git a/src/jsx_parser.erl b/src/jsx_parser.erl
index eef70c1..71df417 100644
--- a/src/jsx_parser.erl
+++ b/src/jsx_parser.erl
@@ -52,7 +52,7 @@ parser(Handler, State, Opts) ->
                         Opts) of
                     {incomplete, _} -> ?error([Handler, Stack, Opts])
                     ; Events -> Events
-                end 
+                end
             ; (Tokens) ->
                 State(Tokens, Handler, Stack, Opts)
         end
@@ -574,13 +574,13 @@ incomplete_test_() ->
 
 encode(Term) -> encode(Term, []).
 
-encode(Term, Opts) -> 
+encode(Term, Opts) ->
     try (parser(jsx, [], Opts))(Term)
     catch error:badarg -> {error, badarg}
     end.
 
 
-encode_test_() ->    
+encode_test_() ->
     [
         {"naked string", ?_assertEqual(
             encode([{string, <<"a string\n">>}, end_json]), [{string, <<"a string\n">>}, end_json]
@@ -803,7 +803,7 @@ bad_utf8_test_() ->
         },
         {"all continuation bytes",
             ?_assert(is_bad(xcode(<<(list_to_binary(lists:seq(16#0080, 16#00bf)))/binary>>)))
-        },        
+        },
         {"all continuation bytes replaced",
             ?_assertEqual(
                 xcode(<<(list_to_binary(lists:seq(16#0080, 16#00bf)))/binary>>, [replaced_bad_utf8]),
@@ -1034,7 +1034,7 @@ check_bad(List) ->
 
 
 check_replaced(List) ->
-    [] == lists:dropwhile(fun({_, [{string, <<16#fffd/utf8>>}|_]}) -> true ; (_) -> false 
+    [] == lists:dropwhile(fun({_, [{string, <<16#fffd/utf8>>}|_]}) -> true ; (_) -> false
         end,
         check(List, [replaced_bad_utf8], [])
     ).
@@ -1052,7 +1052,7 @@ check([], _Opts, Acc) -> Acc;
 check([H|T], Opts, Acc) ->
     R = encode(to_fake_utf(H, utf8), Opts),
     check(T, Opts, [{H, R}] ++ Acc).
-    
+
 
 noncharacters() -> lists:seq(16#fffe, 16#ffff).
 
@@ -1073,7 +1073,7 @@ reserved_space() -> lists:seq(16#fdd0, 16#fdef).
 good() -> lists:seq(16#0000, 16#d7ff) ++ lists:seq(16#e000, 16#fdcf) ++ lists:seq(16#fdf0, 16#fffd).
 
 good_extended() -> [16#10000, 16#20000, 16#30000, 16#40000, 16#50000,
-        16#60000, 16#70000, 16#80000, 16#90000, 16#a0000, 
+        16#60000, 16#70000, 16#80000, 16#90000, 16#a0000,
         16#b0000, 16#c0000, 16#d0000, 16#e0000, 16#f0000
     ] ++ lists:seq(16#100000, 16#10fffd).
 
@@ -1082,7 +1082,7 @@ good_extended() -> [16#10000, 16#20000, 16#30000, 16#40000, 16#50000,
 to_fake_utf(N, utf8) when N < 16#0080 -> <<N:8>>;
 to_fake_utf(N, utf8) when N < 16#0800 ->
     <<0:5, Y:5, X:6>> = <<N:16>>,
-    <<2#110:3, Y:5, 2#10:2, X:6>>; 
+    <<2#110:3, Y:5, 2#10:2, X:6>>;
 to_fake_utf(N, utf8) when N < 16#10000 ->
     <<Z:4, Y:6, X:6>> = <<N:16>>,
     <<2#1110:4, Z:4, 2#10:2, Y:6, 2#10:2, X:6>>;
diff --git a/src/jsx_to_json.erl b/src/jsx_to_json.erl
index f593c96..25ab713 100644
--- a/src/jsx_to_json.erl
+++ b/src/jsx_to_json.erl
@@ -37,13 +37,13 @@
 
 
 -spec to_json(Source::any(), Opts::opts()) -> binary().
-    
+
 to_json(Source, Opts) when is_list(Opts) ->
     (jsx:encoder(?MODULE, Opts, jsx_utils:extract_opts(Opts ++ [escaped_strings])))(Source).
 
 
 -spec format(Source::binary(), Opts::opts()) -> binary().
-    
+
 format(Source, Opts) when is_binary(Source) andalso is_list(Opts) ->
     (jsx:decoder(?MODULE, Opts, jsx_utils:extract_opts(Opts ++ [escaped_strings])))(Source).
 
@@ -210,7 +210,7 @@ basic_format_test_() ->
                     \"a list\": [true, false]
                 },
                 [[{}]]
-            ]">>, []), 
+            ]">>, []),
             <<"[{\"key\":\"value\",\"another key\":\"another value\",\"a list\":[true,false]},[[{}]]]">>
         )},
         {"simple nested structure",
@@ -236,7 +236,7 @@ basic_to_json_test_() ->
             to_json(
                 [{<<"key">>, <<"value">>}],
                 []
-            ), 
+            ),
             <<"{\"key\":\"value\"}">>
         )},
         {"nested object", ?_assertEqual(
@@ -280,14 +280,14 @@ opts_test_() ->
         )},
         {"specific indent/space", ?_assertEqual(
             format(
-                <<"\n{\n\"key\"  :  [],\n\"another key\"  :  true\n}\n">>, 
+                <<"\n{\n\"key\"  :  [],\n\"another key\"  :  true\n}\n">>,
                 [{space, 2}, {indent, 3}]
             ),
             <<"{\n   \"key\":  [],\n   \"another key\":  true\n}">>
         )},
         {"nested structures", ?_assertEqual(
             format(
-                <<"[{\"key\":\"value\", \"another key\": \"another value\"}, [[true, false, null]]]">>, 
+                <<"[{\"key\":\"value\", \"another key\": \"another value\"}, [[true, false, null]]]">>,
                 [{space, 2}, {indent, 2}]
             ),
             <<"[\n  {\n    \"key\":  \"value\",\n    \"another key\":  \"another value\"\n  },\n  [\n    [\n      true,\n      false,\n      null\n    ]\n  ]\n]">>
@@ -310,5 +310,5 @@ opts_test_() ->
         )}
     ].
 
-    
+
 -endif.
\ No newline at end of file
diff --git a/src/jsx_to_term.erl b/src/jsx_to_term.erl
index d124cc1..6ef9f58 100644
--- a/src/jsx_to_term.erl
+++ b/src/jsx_to_term.erl
@@ -45,7 +45,7 @@
 
 
 -spec to_term(Source::binary(), Opts::opts()) -> json_value().
-    
+
 to_term(Source, Opts) when is_list(Opts) ->
     (jsx:decoder(?MODULE, Opts, jsx_utils:extract_opts(Opts)))(Source).
 
@@ -81,7 +81,7 @@ handle_event(end_object, {[[], Last|Terms], Opts}) ->
     {[[post_decode([{}], Opts)] ++ Last] ++ Terms, Opts};
 handle_event(end_object, {[Object, Last|Terms], Opts}) ->
     {[[post_decode(lists:reverse(Object), Opts)] ++ Last] ++ Terms, Opts};
-    
+
 handle_event(start_array, {Terms, Opts}) -> {[[]|Terms], Opts};
 handle_event(end_array, {[List, {key, Key}, Last|Terms], Opts}) ->
     {[[{Key, post_decode(lists:reverse(List), Opts)}] ++ Last] ++ Terms, Opts};
@@ -148,7 +148,7 @@ comp_json() ->
         {},
         [],
         [{},{}],
-        {\"key\": [], \"another key\": {}}    
+        {\"key\": [], \"another key\": {}}
     ]">>.
 
 comp_term() ->
@@ -215,7 +215,7 @@ post_decoders_test_() ->
                 {<<"literals">>, [false, false, false]},
                 {<<"strings">>, [false, false, false]},
                 {<<"numbers">>, [false, false, false]}
-            ]}]            
+            ]}]
         )},
         {"atoms_to_strings", ?_assertEqual(
             to_term(JSON, [{post_decode, fun(V) when is_atom(V) -> unicode:characters_to_binary(atom_to_list(V)); (V) -> V end}]),
@@ -226,5 +226,5 @@ post_decoders_test_() ->
             ]}]
         )}
     ].
-    
+
 -endif.
diff --git a/src/jsx_utils.erl b/src/jsx_utils.erl
index 58ffed7..1144a70 100644
--- a/src/jsx_utils.erl
+++ b/src/jsx_utils.erl
@@ -110,7 +110,7 @@ valid_flags() ->
         json_escape,            %% escaped_strings
         ignore_bad_escapes      %% ignored_bad_escapes
     ].
- 
+
 
 extract_opts(Opts) ->
     extract_parser_opts(Opts, []).
diff --git a/src/jsx_verify.erl b/src/jsx_verify.erl
index 1a91b37..21e4fe1 100644
--- a/src/jsx_verify.erl
+++ b/src/jsx_verify.erl
@@ -35,7 +35,7 @@
 
 
 -spec is_json(Source::binary(), Opts::opts()) -> true | false.
-    
+
 is_json(Source, Opts) when is_list(Opts) ->
     try (jsx:decoder(?MODULE, Opts, jsx_utils:extract_opts(Opts)))(Source)
     catch error:badarg -> false
@@ -92,39 +92,39 @@ json_true_test_() ->
     [
         {"empty object", ?_assert(is_json(<<"{}">>, []))},
         {"empty array", ?_assert(is_json(<<"[]">>, []))},
-        {"whitespace", 
-            ?_assert(is_json(<<" \n    \t   \r   [true]   \t    \n\r  ">>, 
+        {"whitespace",
+            ?_assert(is_json(<<" \n    \t   \r   [true]   \t    \n\r  ">>,
                     []
                 )
             )
         },
-        {"nested terms", 
+        {"nested terms",
             ?_assert(is_json(
-                    <<"[{ \"x\": [ {}, {}, {} ], \"y\": [{}] }, {}, [[[]]]]">>, 
+                    <<"[{ \"x\": [ {}, {}, {} ], \"y\": [{}] }, {}, [[[]]]]">>,
                     []
                 )
             )
         },
-        {"numbers", 
+        {"numbers",
             ?_assert(is_json(
-                    <<"[ -1.0, -1, -0, 0, 1e-1, 1, 1.0, 1e1 ]">>, 
+                    <<"[ -1.0, -1, -0, 0, 1e-1, 1, 1.0, 1e1 ]">>,
                     []
                 )
             )
         },
-        {"strings", 
+        {"strings",
             ?_assert(is_json(
-                    <<"[ \"a\", \"string\", \"in\", \"multiple\", \"acts\" ]">>, 
+                    <<"[ \"a\", \"string\", \"in\", \"multiple\", \"acts\" ]">>,
                     []
                 )
             )
         },
-        {"literals", 
+        {"literals",
             ?_assert(is_json(<<"[ true, false, null ]">>, []))
         },
-        {"nested objects", 
+        {"nested objects",
             ?_assert(is_json(<<"{\"key\": { \"key\": true}}">>, []))
-        },        
+        },
         {"repeated key ok", ?_assert(is_json(
                     <<"{\"key\": true, \"key\": true}">>,
                     [repeated_keys]
@@ -142,7 +142,7 @@ json_true_test_() ->
 json_false_test_() ->
     [
         {"unbalanced list", ?_assertNot(is_json(<<"[]]">>, []))},
-        {"trailing comma", 
+        {"trailing comma",
             ?_assertNot(is_json(<<"[ true, false, null, ]">>, []))
         },
         {"unquoted key", ?_assertNot(is_json(<<"{ key: false }">>, []))},
@@ -168,21 +168,21 @@ term_true_test_() ->
         {"empty object", ?_assert(is_term([{}], []))},
         {"empty array", ?_assert(is_term([], []))},
         {"whitespace", ?_assert(is_term([    true      ], []))},
-        {"nested terms", 
+        {"nested terms",
             ?_assert(is_term([[{x, [[{}], [{}], [{}]]}, {y, [{}]}], [{}], [[[]]]], []))
         },
-        {"numbers", 
+        {"numbers",
             ?_assert(is_term([-1.0, -1, -0, 0, 1.0e-1, 1, 1.0, 1.0e1], []))
         },
-        {"strings", 
+        {"strings",
             ?_assert(is_term(
-                    [<<"a">>, <<"string">>, <<"in">>, <<"multiple">>, <<"acts">>], 
+                    [<<"a">>, <<"string">>, <<"in">>, <<"multiple">>, <<"acts">>],
                     []
                 )
             )
         },
         {"literals", ?_assert(is_term([ true, false, null ], []))},
-        {"nested objects", ?_assert(is_term([{key, [{key, true}]}], []))},        
+        {"nested objects", ?_assert(is_term([{key, [{key, true}]}], []))},
         {"repeated key ok", ?_assert(is_term(
                     [{key, true}, {key, true}],
                     []
@@ -224,6 +224,6 @@ term_false_test_() ->
             )
         }
     ].
-        
-    
+
+
 -endif.
\ No newline at end of file