option to allow trailing characters while parsing

This adds an option `allowtrailing` to tolerate additional trailing characters in the buffer while parsing json. It is off by default, which keeps the parser strict and tries to parse the entire buffer as json. But when it is switched on, it allows parsing a valid json from the beginning of the buffer and ignore any additional following characters if they are present.

This is useful in parsing scenarios that contain multiple json objects without a delimiter. E.g. `{"name": "value"}{"name": "value"}`. Or a json followed by other characters. E.g. `{"name": "value"} : this is...`.

This also matches the pre 1.x behavior of this package.

Author: tanmaykm

src/lazy.jl

@@ -59,6 +59,7 @@ Currently supported keyword arguments include:
   - `inf::String = "Infinity"`: the string that will be used to parse `Inf` if `allownan=true`
   - `nan::String = "NaN"`: the string that will be sued to parse `NaN` if `allownan=true`
   - `jsonlines::Bool = false`: whether the JSON input should be treated as an implicit array, with newlines separating individual JSON elements with no leading `'['` or trailing `']'` characters. Common in logging or streaming workflows. Defaults to `true` when used with `JSON.parsefile` and the filename extension is `.jsonl` or `ndjson`. Note this ensures that parsing will _always_ return an array at the root-level.
+  - `allowtrailing::Bool = false`: whether to tolerate trailing characters after parsing a valid JSON element
 
 Note that validation is only fully done on `null`, `true`, and `false`,
 while other values are only lazily inferred from the first non-whitespace character:
@@ -80,6 +81,7 @@ function lazy end
     inf::String = "Infinity"
     nan::String = "NaN"
     jsonlines::Bool = false
+    allowtrailing::Bool = false
 end
 
 lazy(io::Union{IO, Base.AbstractCmd}; kw...) = lazy(Base.read(io); kw...)
@@ -163,6 +165,7 @@ getpos(x) = getfield(x, :pos)
 gettype(x) = getfield(x, :type)
 getopts(x) = getfield(x, :opts)
 getisroot(x) = getfield(x, :isroot)
+getallowtrailing(x) = getopts(x).allowtrailing
 
 const LazyValues{T} = Union{LazyValue{T}, LazyObject{T}, LazyArray{T}}
 
@@ -376,7 +379,7 @@ function applyarray(keyvalfunc, x::LazyValues)
         # for jsonlines, we need to make sure that recursive
         # lazy values *don't* consider individual lines *also*
         # to be jsonlines
-        opts = LazyOptions(; allownan=opts.allownan, ninf=opts.ninf, inf=opts.inf, nan=opts.nan, jsonlines=false)
+        opts = LazyOptions(; allownan=opts.allownan, ninf=opts.ninf, inf=opts.inf, nan=opts.nan, jsonlines=false, allowtrailing=opts.allowtrailing)
     end
     i = 1
     while true

src/parse.jl

@@ -191,7 +191,7 @@ parse(x::LazyValue, ::Type{T}=Any; dicttype::Type{O}=DEFAULT_OBJECT_TYPE, null=n
 
 function _parse(x::LazyValue, ::Type{T}, dicttype::Type{O}, null, style::StructStyle) where {T,O}
     y, pos = StructUtils.make(style, T, x)
-    getisroot(x) && checkendpos(x, T, pos)
+    getisroot(x) && !getallowtrailing(x) && checkendpos(x, T, pos)
     return y
 end
 
@@ -205,7 +205,7 @@ end
 function _parse(x::LazyValue, ::Type{Any}, ::Type{DEFAULT_OBJECT_TYPE}, null, ::StructStyle)
     out = ValueClosure()
     pos = applyvalue(out, x, null)
-    getisroot(x) && checkendpos(x, Any, pos)
+    getisroot(x) && !getallowtrailing(x) && checkendpos(x, Any, pos)
     return out.value
 end
 

test/parse.jl

@@ -771,3 +771,18 @@ end
     @test_throws ArgumentError JSON.parse("{}", Tuple{Int, Int, Int})
     @test_throws ArgumentError JSON.parse("{\"a\":1,\"b\":2}", Tuple{Int, Int, Int})
 end
+
+@testset "allowtrailing" begin
+    # default behavior: trailing content causes an error
+    @test_throws ArgumentError JSON.parse("{\"hello\": \"world\"} asdaa")
+    @test_throws ArgumentError JSON.parse("[1,2,3] extra")
+    @test_throws ArgumentError JSON.parse("123 {}")
+
+    # allowtrailing=true: trailing content is ignored
+    @test JSON.parse("{\"hello\": \"world\"} asdaa", allowtrailing=true) == JSON.Object("hello" => "world")
+    @test JSON.parse("[1,2,3] extra", allowtrailing=true) == Any[1, 2, 3]
+    @test JSON.parse("123 {}", allowtrailing=true) == 123
+
+    # allowtrailing=true with typed parse
+    @test JSON.parse("{\"a\": 1, \"b\": 2.0, \"c\": \"hi\"} trailing", D; allowtrailing=true) == D(1, 2.0, "hi")
+end