Add new uber-simple vendor/jsonx.jl for true no-dependency JSON functionality that can be directly vendored in

Author: quinnj

.github/workflows/vendor-tests.yml

@@ -0,0 +1,48 @@
+name: Vendor Tests
+
+on:
+  push:
+    paths:
+      - 'vendor/**'
+  pull_request:
+    paths:
+      - 'vendor/**'
+
+jobs:
+  test:
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - '1' # automatically expands to the latest stable 1.x release of Julia
+          - 'min'
+          - 'pre'
+        os:
+          - ubuntu-latest
+          - windows-latest
+        arch:
+          - x64
+        include:
+          - os: macOS-latest
+            arch: aarch64
+            version: 1
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Setup Julia
+      uses: julia-actions/setup-julia@v2
+      with:
+        version: ${{ matrix.version }}
+        arch: ${{ matrix.arch }}
+        
+    - name: Cache Julia packages
+      uses: julia-actions/cache@v2
+      
+    - name: Run vendor tests
+      run: |
+        cd vendor
+        julia test.jl 

README.md

@@ -71,6 +71,10 @@ JSON.isvalidjson(json)
 JSON.json("test.json", j)
 ```
 
+## 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.
+
 ## Contributing and Questions
 
 Contributions are very welcome, as are feature requests and suggestions. Please open an

src/lazy.jl

@@ -269,8 +269,8 @@ function applyobject(keyvalfunc, x::LazyValues)
     @nextbyte
     b == UInt8('}') && return pos + 1
     while true
-        # applystring returns key as a PtrString
-        key, pos = @inline applystring(nothing, LazyValue(buf, pos, JSONTypes.STRING, getopts(x), false))
+        # parsestring returns key as a PtrString
+        key, pos = @inline parsestring(LazyValue(buf, pos, JSONTypes.STRING, getopts(x), false))
         @nextbyte
         if b != UInt8(':')
             error = ExpectedColon
@@ -455,7 +455,7 @@ StructUtils.keyeq(x::PtrString, y::Symbol) = convert(Symbol, x) == y
 # or not. It allows materialize, _binary, etc. to deal
 # with the string data appropriately without forcing a String allocation
 # PtrString should NEVER be visible to users though!
-function applystring(f, x::LazyValue)
+function parsestring(x::LazyValue)
     buf, pos = getbuf(x), getpos(x)
     len, b = getlength(buf), getbyte(buf, pos)
     if b != UInt8('"')
@@ -483,12 +483,7 @@ function applystring(f, x::LazyValue)
         @nextbyte(false)
     end
     str = PtrString(pointer(buf, spos), pos - spos, escaped)
-    if f === nothing
-        return str, pos + 1
-    else
-        f(str)
-        return pos + 1
-    end
+    return str, pos + 1
 
 @label invalid
     invalid(error, buf, pos, "string")
@@ -525,7 +520,30 @@ macro check_special(special, value)
     end)
 end
 
-function applynumber(valfunc, x::LazyValue)
+const INT = 0x00
+const FLOAT = 0x01
+const BIGINT = 0x02
+const BIGFLOAT = 0x03
+const BIG_ZERO = BigInt(0)
+
+struct NumberResult
+    tag::UInt8
+    int::Int64
+    float::Float64
+    bigint::BigInt
+    bigfloat::BigFloat
+    NumberResult(int::Int64) = new(INT, int)
+    NumberResult(float::Float64) = new(FLOAT, Int64(0), float)
+    NumberResult(bigint::BigInt) = new(BIGINT, Int64(0), 0.0, bigint)
+    NumberResult(bigfloat::BigFloat) = new(BIGFLOAT, Int64(0), 0.0, BIG_ZERO, bigfloat)
+end
+
+isint(x::NumberResult) = x.tag == INT
+isfloat(x::NumberResult) = x.tag == FLOAT
+isbigint(x::NumberResult) = x.tag == BIGINT
+isbigfloat(x::NumberResult) = x.tag == BIGFLOAT
+
+@inline function parsenumber(x::LazyValue)
     buf = getbuf(x)
     pos = getpos(x)
     len = getlength(buf)
@@ -610,23 +628,20 @@ function applynumber(valfunc, x::LazyValue)
             # if we overflowed, then let's try BigFloat
             bres = Parsers.xparse2(BigFloat, buf, startpos, len)
             if !Parsers.invalid(bres.code)
-                valfunc(bres.val)
-                return startpos + bres.tlen
+                return NumberResult(bres.val), startpos + bres.tlen
             end
         end
         if Parsers.invalid(res.code)
             error = InvalidNumber
             @goto invalid
         end
-        valfunc(res.val)
-        return startpos + res.tlen
+        return NumberResult(res.val), startpos + res.tlen
     else
         if overflow
-            valfunc(isneg ? -bval : bval)
+            return NumberResult(isneg ? -bval : bval), pos
         else
-            valfunc(isneg ? -val : val)
+            return NumberResult(isneg ? -val : val), pos
         end
-        return pos
     end
 
 @label invalid
@@ -643,9 +658,11 @@ function skip(x::LazyValues)
     elseif T == JSONTypes.ARRAY
         return applyarray((i, v) -> 0, x)
     elseif T == JSONTypes.STRING
-        return applystring(s -> 0, x)
+        _, pos = parsestring(x)
+        return pos
     elseif T == JSONTypes.NUMBER
-        return applynumber(n -> 0, x)
+        _, pos = parsenumber(x)
+        return pos
     elseif T == JSONTypes.TRUE
         return getpos(x) + 4
     elseif T == JSONTypes.FALSE
@@ -716,7 +733,7 @@ function Base.show(io::IO, x::LazyValue)
             show(io, MIME"text/plain"(), la)
         end
     elseif T == JSONTypes.STRING
-        str, _ = applystring(nothing, x)
+        str, _ = parsestring(x)
         Base.print(io, "JSON.LazyValue(", repr(convert(String, str)), ")")
     elseif T == JSONTypes.NULL
         Base.print(io, "JSON.LazyValue(nothing)")

src/parse.jl

@@ -266,9 +266,21 @@ function applyvalue(f, x::LazyValues, null)
         f(arr)
         return pos
     elseif type == JSONTypes.STRING
-        return applystring(s -> f(convert(String, s)), x)
+        str, pos = parsestring(x)
+        f(convert(String, str))
+        return pos
     elseif type == JSONTypes.NUMBER
-        return applynumber(f, x)
+        num, pos = parsenumber(x)
+        if isint(num)
+            f(num.int)
+        elseif isfloat(num)
+            f(num.float)
+        elseif isbigint(num)
+            f(num.bigint)
+        else
+            f(num.bigfloat)
+        end
+        return pos
     elseif type == JSONTypes.NULL
         f(null)
         return getpos(x) + 4
@@ -312,15 +324,30 @@ StructUtils.liftkey(st::StructStyle, ::Type{T}, x::PtrString) where {T} =
     StructUtils.liftkey(st, T, convert(String, x))
 StructUtils.lift(f, st::StructStyle, ::Type{T}, x::PtrString, tags) where {T} =
     StructUtils.lift(f, st, T, convert(String, x), tags)
+StructUtils.lift(st::StructStyle, ::Type{T}, x::PtrString, tags) where {T} =
+    StructUtils.lift(st, T, convert(String, x), tags)
 StructUtils.make!(f, st::StructStyle, ::Type{T}, x::PtrString, tags) where {T} =
     StructUtils.make!(f, st, T, convert(String, x), tags)
 
 function StructUtils.lift(f, style::StructStyle, ::Type{T}, x::LazyValues, tags) where {T}
     type = gettype(x)
     if type == JSONTypes.STRING
-        return applystring(s -> StructUtils.lift(f, style, T, s, tags), x)
+        ptrstr, pos = parsestring(x)
+        val = StructUtils.lift(style, T, ptrstr, tags)
+        f(val)
+        return pos
     elseif type == JSONTypes.NUMBER
-        return applynumber(x -> StructUtils.lift(f, style, T, x, tags), x)
+        num, pos = parsenumber(x)
+        if isint(num)
+            StructUtils.lift(f, style, T, num.int, tags)
+        elseif isfloat(num)
+            StructUtils.lift(f, style, T, num.float, tags)
+        elseif isbigint(num)
+            StructUtils.lift(f, style, T, num.bigint, tags)
+        else
+            StructUtils.lift(f, style, T, num.bigfloat, tags)
+        end
+        return pos
     elseif type == JSONTypes.NULL
         StructUtils.lift(f, style, T, nullvalue(style), tags)
         return getpos(x) + 4

src/utils.jl

@@ -38,8 +38,6 @@ module JSONTypes
     Base.show(io::IO, x::T) = Base.print(io, "JSONTypes.", names[x])
 end
 
-
-
 isjsonl(filename) = endswith(filename, ".jsonl") || endswith(filename, ".ndjson")
 
 getlength(buf::AbstractVector{UInt8}) = length(buf)

test/lazy.jl

@@ -67,9 +67,9 @@ end
     # error cases
     x = JSON.lazy("{}")
     @test_throws ArgumentError JSON.applyarray((i, v) -> nothing, x)
-    @test_throws ArgumentError JSON.applystring(nothing, x)
+    @test_throws ArgumentError JSON.parsestring(x)
     x = JSON.lazy("{}"; allownan=true)
-    @test_throws ArgumentError JSON.applynumber(x -> nothing, x)
+    @test_throws ArgumentError JSON.parsenumber(x)
 
     # lazy indexing selection support
     # examples from https://support.smartbear.com/alertsite/docs/monitors/api/endpoint/jsonpath.html

vendor/README.md

@@ -0,0 +1,96 @@
+# JSONX - Simple JSON Parser
+
+A simple, no-dependency JSON parser that can be vendored (copied/pasted) into other packages.
+
+## Features
+
+### Parsing
+- `JSONX.parse(json_str::String)` - Parse a JSON string
+- `JSONX.parse(bytes::AbstractVector{UInt8})` - Parse JSON from byte array
+- `JSONX.parsefile(filename::String)` - Parse JSON from a file
+
+### Writing
+- `JSONX.json(value)` - Convert a Julia value to JSON string
+
+### Supported Types
+
+**Reading (JSON → Julia):**
+- `null` → `nothing`
+- `true`/`false` → `Bool`
+- Numbers → `Float64` (all numbers are parsed as Float64)
+- Strings → `String` (with full Unicode support)
+- Arrays → `Vector{Any}`
+- Objects → `Dict{String, Any}`
+
+**Writing (Julia → JSON):**
+- `nothing`/`missing` → `null`
+- `Bool` → `true`/`false`
+- `Number` → JSON number
+- `AbstractString` → JSON string
+- `AbstractVector`/`AbstractSet`/`Tuple` → JSON array
+- `AbstractDict`/`NamedTuple` → JSON object
+- `Symbol`/`Enum` → JSON string
+
+### Unicode Support
+
+JSONX includes full Unicode support:
+- Proper Unicode escape sequence parsing (`\uXXXX`)
+- UTF-16 surrogate pair handling
+- Lone surrogate handling
+- All standard JSON escape sequences (`\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, `\t`)
+
+## Usage
+
+```julia
+using JSONX
+
+# Parse JSON
+data = JSONX.parse("{\"name\":\"John\",\"age\":30}")
+# Returns: Dict("name" => "John", "age" => 30.0)
+
+# Parse from bytes
+bytes = Vector{UInt8}("{\"key\":\"value\"}")
+data = JSONX.parse(bytes)
+
+# Parse from file
+data = JSONX.parsefile("data.json")
+
+# Write JSON
+json_str = JSONX.json(Dict("a" => 1, "b" => 2))
+# Returns: "{\"a\":1,\"b\":2}"
+
+# Unicode examples
+JSONX.parse("\"Hello 世界! 🌍\"")  # Full Unicode support
+JSONX.parse("\"\\u0048\\u0065\\u006C\\u006C\\u006F\"")  # Unicode escapes
+```
+
+## Error Handling
+
+JSONX provides detailed error messages for invalid JSON:
+- Unexpected end of input
+- Invalid escape sequences
+- Malformed Unicode escapes
+- Trailing commas
+- Control characters in strings
+- Invalid number formats
+
+## Limitations
+
+Compared to the full JSON.jl package, JSONX is intentionally simplified:
+
+- **No integer parsing**: All numbers are parsed as Float64
+- **No custom type parsing**: Only returns basic Julia types
+- **No configuration options**: Uses fixed defaults
+- **No streaming**: Loads entire input into memory
+- **No pretty printing**: Output is compact only
+- **No schema validation**: Basic JSON validation only
+- **No performance optimizations**: Simple, readable implementation
+
+## Implementation Notes
+
+- **No dependencies**: Uses only Base Julia functionality
+- **Byte-level processing**: Uses `codeunit` for accurate string handling
+- **Memory efficient**: Avoids unnecessary string concatenation
+- **Error robust**: Comprehensive error checking and reporting
+
+Note: Functions are not exported, so use `JSONX.parse` and `JSONX.json` with the module prefix.