Merge branch 'master' into nz/writefile

Author: nhz2

.github/workflows/CI.yml

@@ -27,6 +27,9 @@ jobs:
           - os: macOS-latest
             arch: aarch64
             version: 1
+          - os: ubuntu-latest
+            arch: x86
+            version: 1
     steps:
       - uses: actions/checkout@v5
       - uses: julia-actions/setup-julia@v2

Project.toml

@@ -1,6 +1,6 @@
 name = "JSON"
 uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
-version = "1.0.0"
+version = "1.2.0"
 
 [deps]
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"

README.md

@@ -1,20 +1,23 @@
 # JSON.jl
 
-This package provides for parsing and printing JSON in pure Julia.
+A Julia package for reading and writing JSON data.
 
 [![Build Status](https://github.com/JuliaIO/JSON.jl/workflows/CI/badge.svg)](https://github.com/JuliaIO/JSON.jl/actions/workflows/CI.yml?query=branch%3Amaster)
 [![codecov.io](http://codecov.io/github/JuliaIO/JSON.jl/coverage.svg?branch=master)](http://codecov.io/github/JuliaIO/JSON.jl?branch=master)
 
 ## Installation
 
-Type `] add JSON` and then hit ⏎ Return at the REPL. You should see `pkg> add JSON`.
+Install JSON using the Julia package manager:
+```julia
+import Pkg
+Pkg.add("JSON")
+```
 
 ## Documentation
 
-- [**STABLE**](https://juliaio.github.io/JSON.jl/stable) — **most recently tagged version of the documentation.**
-- [**LATEST**](https://juliaio.github.io/JSON.jl/dev) — *in-development version of the documentation.*
-
-Documentation includes extensive guides and examples for reading, writing, and migrating from JSON.jl pre.10 or JSON3.jl.
+The [documentation](https://juliaio.github.io/JSON.jl/stable) includes extensive
+guides and examples. It also has advice for migrating to JSON.jl v1.0 from
+JSON.jl v0.21 or JSON3.jl.
 
 ## Basic Usage
 
@@ -79,9 +82,12 @@ df = DataFrame(Tables.dictrowtable(JSON.parse(resp.body; null=missing, allownan=
 
 ## Vendor Directory
 
-This package includes a `vendor/` directory containing a simplified, no-dependency JSON parser (`JSONX`) that can be vendored (copied) into other projects. See the [vendor README](vendor/README.md) for details.
+This package includes a `vendor/` directory containing a simplified,
+no-dependency JSON parser (`JSONX`) that can be vendored (copied) into other
+projects. See the [vendor README](vendor/README.md) for details.
 
 ## Contributing and Questions
 
-Contributions are very welcome, as are feature requests and suggestions. Please open an
-[issue][https://github.com/JuliaIO/JSON.jl/issues] if you encounter any problems or would just like to ask a question.
+Contributions are very welcome, as are feature requests and suggestions. Please
+open an [issue](https://github.com/JuliaIO/JSON.jl/issues) if you encounter any
+problems or would just like to ask a question.

docs/src/writing.md

@@ -171,6 +171,8 @@ JSON.json(pi_value; float_style=:exp, float_precision=3)
 # [3.142e+00]
 ```
 
+`float_precision` must be a positive integer when `float_style` is `:fixed` or `:exp`.
+
 ### JSON Lines Format
 
 The JSON Lines format is useful for streaming records where each line is a JSON value:

src/lazy.jl

@@ -204,7 +204,7 @@ StructUtils.nulllike(::StructUtils.StructStyle, x::LazyValues) = gettype(x) == J
 
 # core method that detects what JSON value is at the current position
 # and immediately returns an appropriate LazyValue instance
-function _lazy(buf, pos, len, b, opts, isroot=false)
+function _lazy(buf, pos::Int, len, b, opts, isroot=false)
     if opts.jsonlines
         return LazyValue(buf, pos, JSONTypes.ARRAY, opts, isroot)
     elseif b == UInt8('{')
@@ -256,7 +256,7 @@ end
 # returns a `pos` value that notes the next position where parsing should continue
 # this is essentially the `StructUtils.applyeach` implementation for LazyValues w/ type OBJECT
 function applyobject(keyvalfunc, x::LazyValues)
-    pos = getpos(x)
+    pos::Int = getpos(x)
     buf = getbuf(x)
     len = getlength(buf)
     opts = getopts(x)
@@ -270,17 +270,19 @@ function applyobject(keyvalfunc, x::LazyValues)
     b == UInt8('}') && return pos + 1
     while true
         # parsestring returns key as a PtrString
-        key, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
-        @nextbyte
-        if b != UInt8(':')
-            error = ExpectedColon
-            @goto invalid
+        GC.@preserve buf begin
+            key, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
+            @nextbyte
+            if b != UInt8(':')
+                error = ExpectedColon
+                @goto invalid
+            end
+            pos += 1
+            @nextbyte
+            # we're now positioned at the start of the value
+            val = _lazy(buf, pos, len, b, opts)
+            ret = keyvalfunc(key, val)
         end
-        pos += 1
-        @nextbyte
-        # we're now positioned at the start of the value
-        val = _lazy(buf, pos, len, b, opts)
-        ret = keyvalfunc(key, val)
         # if ret is an EarlyReturn, then we're short-circuiting
         # parsing via e.g. selection syntax, so return immediately
         ret isa StructUtils.EarlyReturn && return ret
@@ -356,7 +358,7 @@ end
 # returns a `pos` value that notes the next position where parsing should continue
 # this is essentially the `StructUtils.applyeach` implementation for LazyValues w/ type ARRAY
 function applyarray(keyvalfunc, x::LazyValues)
-    pos = getpos(x)
+    pos::Int = getpos(x)
     buf = getbuf(x)
     len = getlength(buf)
     opts = getopts(x)
@@ -544,7 +546,7 @@ isbigfloat(x::NumberResult) = x.tag == BIGFLOAT
 
 @inline function parsenumber(x::LazyValue)
     buf = getbuf(x)
-    pos = getpos(x)
+    pos::Int = getpos(x)
     len = getlength(buf)
     opts = getopts(x)
     b = getbyte(buf, pos)
@@ -627,14 +629,14 @@ isbigfloat(x::NumberResult) = x.tag == BIGFLOAT
             # if we overflowed, then let's try BigFloat
             bres = Parsers.xparse2(BigFloat, buf, startpos, len)
             if !Parsers.invalid(bres.code)
-                return NumberResult(bres.val), startpos + bres.tlen
+                return NumberResult(bres.val), startpos + Int(bres.tlen)
             end
         end
         if Parsers.invalid(res.code)
             error = InvalidNumber
             @goto invalid
         end
-        return NumberResult(res.val), startpos + res.tlen
+        return NumberResult(res.val), Int(startpos + res.tlen)
     else
         if overflow
             return NumberResult(isneg ? -bval : bval), pos
@@ -732,8 +734,11 @@ function Base.show(io::IO, x::LazyValue)
             show(io, MIME"text/plain"(), la)
         end
     elseif T == JSONTypes.STRING
-        str, _ = parsestring(x)
-        Base.print(io, "JSON.LazyValue(", repr(convert(String, str)), ")")
+        buf = getbuf(x)
+        GC.@preserve buf begin
+            str, _ = parsestring(x)
+            Base.print(io, "JSON.LazyValue(", repr(convert(String, str)), ")")
+        end
     elseif T == JSONTypes.NULL
         Base.print(io, "JSON.LazyValue(nothing)")
     else # bool/number

src/parse.jl

@@ -214,7 +214,7 @@ parse!(x::LazyValue, obj::T; dicttype::Type{O}=DEFAULT_OBJECT_TYPE, null=nothing
 # for LazyValue, if x started at the beginning of the JSON input,
 # then we want to ensure that the entire input was consumed
 # and error if there are any trailing invalid JSON characters
-function checkendpos(x::LazyValue, ::Type{T}, pos) where {T}
+function checkendpos(x::LazyValue, ::Type{T}, pos::Int) where {T}
     buf = getbuf(x)
     len = getlength(buf)
     if pos <= len
@@ -277,8 +277,11 @@ function applyvalue(f, x::LazyValues, null)
         f(arr)
         return pos
     elseif type == JSONTypes.STRING
-        str, pos = parsestring(x)
-        f(convert(String, str))
+        buf = getbuf(x)
+        GC.@preserve buf begin
+            str, pos = parsestring(x)
+            f(convert(String, str))
+        end
         return pos
     elseif type == JSONTypes.NUMBER
         num, pos = parsenumber(x)
@@ -343,9 +346,12 @@ end
 
 function StructUtils.lift(style::StructStyle, ::Type{T}, x::LazyValues, tags=(;)) where {T}
     type = gettype(x)
+    buf = getbuf(x)
     if type == JSONTypes.STRING
-        ptrstr, pos = parsestring(x)
-        str, _ = StructUtils.lift(style, T, ptrstr, tags)
+        GC.@preserve buf begin
+            ptrstr, pos = parsestring(x)
+            str, _ = StructUtils.lift(style, T, ptrstr, tags)
+        end
         return str, pos
     elseif type == JSONTypes.NUMBER
         num, pos = parsenumber(x)
@@ -427,7 +433,7 @@ end
 @generated function StructUtils.maketuple(st::StructStyle, ::Type{T}, x::LazyValues) where {T<:Tuple}
     N = fieldcount(T)
     ex = quote
-        pos = getpos(x)
+        pos::Int = getpos(x)
         buf = getbuf(x)
         len = getlength(buf)
         opts = getopts(x)
@@ -448,7 +454,9 @@ end
         Base.@nexprs $N i -> begin
             if typ == JSONTypes.OBJECT
                 # consume key
-                _, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
+                GC.@preserve buf begin
+                    _, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
+                end
                 @nextbyte
                 if b != UInt8(':')
                     error = ExpectedColon
@@ -483,7 +491,9 @@ end
         while true
             if typ == JSONTypes.OBJECT
                 # consume key
-                _, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
+                GC.@preserve buf begin
+                    _, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, opts, false))
+                end
                 @nextbyte
                 if b != UInt8(':')
                     error = ExpectedColon

src/write.jl

@@ -16,6 +16,9 @@ StructUtils.lower(::JSONStyle, x::AbstractArray{<:Any,0}) = x[1]
 StructUtils.lower(::JSONStyle, x::AbstractArray{<:Any, N}) where {N} = (view(x, ntuple(_ -> :, N - 1)..., j) for j in axes(x, N))
 StructUtils.lower(::JSONStyle, x::AbstractVector) = x
 
+# for pre-1.0 compat, which serialized Tuple object keys by default
+StructUtils.lowerkey(::JSONStyle, x::Tuple) = string(x)
+
 """
     JSON.omit_null(::Type{T})::Bool
     JSON.omit_null(::JSONStyle, ::Type{T})::Bool
@@ -393,6 +396,9 @@ end
 @noinline float_style_throw(fs) = throw(ArgumentError("Invalid float style: $fs"))
 float_style_check(fs) = fs == :shortest || fs == :fixed || fs == :exp || float_style_throw(fs)
 
+@noinline float_precision_throw(fs, fp) = throw(ArgumentError("float_precision must be positive when float_style is $fs; got $fp"))
+float_precision_check(fs, fp) = (fs == :shortest || fp > 0) || float_precision_throw(fs, fp)
+
 # if jsonlines and pretty is not 0 or false, throw an ArgumentError
 @noinline _jsonlines_pretty_throw() = throw(ArgumentError("pretty printing is not supported when writing jsonlines"))
 _jsonlines_pretty_check(jsonlines, pretty) = jsonlines && pretty !== false && !iszero(pretty) && _jsonlines_pretty_throw()
@@ -401,6 +407,7 @@ function json(io::IO, x::T; pretty::Union{Integer,Bool}=false, kw...) where {T}
     opts = WriteOptions(; pretty=pretty === true ? 2 : Int(pretty), kw...)
     _jsonlines_pretty_check(opts.jsonlines, opts.pretty)
     float_style_check(opts.float_style)
+    float_precision_check(opts.float_style, opts.float_precision)
     y = StructUtils.lower(opts.style, x)
     # Use smaller initial buffer size, limited by bufsize
     initial_size = min(sizeguess(y), opts.bufsize)
@@ -423,6 +430,7 @@ function json(x; pretty::Union{Integer,Bool}=false, kw...)
     opts = WriteOptions(; pretty=pretty === true ? 2 : Int(pretty), kw...)
     _jsonlines_pretty_check(opts.jsonlines, opts.pretty)
     float_style_check(opts.float_style)
+    float_precision_check(opts.float_style, opts.float_precision)
     y = StructUtils.lower(opts.style, x)
     buf = stringvec(sizeguess(y))
     pos = json!(buf, 1, y, opts, Any[y], nothing)
@@ -619,11 +627,9 @@ function json!(buf, pos, x, opts::WriteOptions, ancestor_stack::Union{Nothing, V
         if wroteany
             pos -= 1
             pos = indent(buf, pos, local_ind, depth, io, bufsize)
-        else
-            # but if the object/array was empty, we need to do the check manually
-            @checkn 1
         end
         # even if the input is empty and we're jsonlines, the spec says it's ok to end w/ a newline
+        @checkn 1
         @inbounds buf[pos] = opts.jsonlines ? UInt8('\n') : al ? UInt8(']') : UInt8('}')
         return pos + 1
     else
@@ -764,4 +770,4 @@ function anyinvalidnumberchars(x)
         end
     end
     return false
-end
+end