1//! JSON parsing and stringification conforming to RFC 8259. https://datatracker.ietf.org/doc/html/rfc8259
2//!
3//! The low-level `Scanner` API produces `Token`s from an input slice or successive slices of inputs,
4//! The `Reader` API connects a `std.Io.Reader` to a `Scanner`.
5//!
6//! The high-level `parseFromSlice` and `parseFromTokenSource` deserialize a JSON document into a Zig type.
7//! Parse into a dynamically-typed `Value` to load any JSON value for runtime inspection.
8//!
9//! The low-level `writeStream` emits syntax-conformant JSON tokens to a `std.Io.Writer`.
10//! The high-level `stringify` serializes a Zig or `Value` type into JSON.
11
12const builtin = @import("builtin");
13const std = @import("std");
14const testing = std.testing;
15
16test Scanner {
17 var scanner = Scanner.initCompleteInput(testing.allocator, "{\"foo\": 123}\n");
18 defer scanner.deinit();
19 try testing.expectEqual(Token.object_begin, try scanner.next());
20 try testing.expectEqualSlices(u8, "foo", (try scanner.next()).string);
21 try testing.expectEqualSlices(u8, "123", (try scanner.next()).number);
22 try testing.expectEqual(Token.object_end, try scanner.next());
23 try testing.expectEqual(Token.end_of_document, try scanner.next());
24}
25
26test parseFromSlice {
27 var parsed_str = try parseFromSlice([]const u8, testing.allocator, "\"a\\u0020b\"", .{});
28 defer parsed_str.deinit();
29 try testing.expectEqualSlices(u8, "a b", parsed_str.value);
30
31 const T = struct { a: i32 = -1, b: [2]u8 };
32 var parsed_struct = try parseFromSlice(T, testing.allocator, "{\"b\":\"xy\"}", .{});
33 defer parsed_struct.deinit();
34 try testing.expectEqual(@as(i32, -1), parsed_struct.value.a); // default value
35 try testing.expectEqualSlices(u8, "xy", parsed_struct.value.b[0..]);
36}
37
38test Value {
39 var parsed = try parseFromSlice(Value, testing.allocator, "{\"anything\": \"goes\"}", .{});
40 defer parsed.deinit();
41 try testing.expectEqualSlices(u8, "goes", parsed.value.object.get("anything").?.string);
42}
43
44test Stringify {
45 var out: std.Io.Writer.Allocating = .init(testing.allocator);
46 var write_stream: Stringify = .{
47 .writer = &out.writer,
48 .options = .{ .whitespace = .indent_2 },
49 };
50 defer out.deinit();
51 try write_stream.beginObject();
52 try write_stream.objectField("foo");
53 try write_stream.write(123);
54 try write_stream.endObject();
55 const expected =
56 \\{
57 \\ "foo": 123
58 \\}
59 ;
60 try testing.expectEqualSlices(u8, expected, out.written());
61}
62
63pub const ObjectMap = @import("json/dynamic.zig").ObjectMap;
64pub const Array = @import("json/dynamic.zig").Array;
65pub const Value = @import("json/dynamic.zig").Value;
66
67pub const ArrayHashMap = @import("json/hashmap.zig").ArrayHashMap;
68
69pub const Scanner = @import("json/Scanner.zig");
70pub const validate = Scanner.validate;
71pub const Error = Scanner.Error;
72pub const default_buffer_size = Scanner.default_buffer_size;
73pub const Token = Scanner.Token;
74pub const TokenType = Scanner.TokenType;
75pub const Diagnostics = Scanner.Diagnostics;
76pub const AllocWhen = Scanner.AllocWhen;
77pub const default_max_value_len = Scanner.default_max_value_len;
78pub const Reader = Scanner.Reader;
79pub const isNumberFormattedLikeAnInteger = Scanner.isNumberFormattedLikeAnInteger;
80
81pub const ParseOptions = @import("json/static.zig").ParseOptions;
82pub const Parsed = @import("json/static.zig").Parsed;
83pub const parseFromSlice = @import("json/static.zig").parseFromSlice;
84pub const parseFromSliceLeaky = @import("json/static.zig").parseFromSliceLeaky;
85pub const parseFromTokenSource = @import("json/static.zig").parseFromTokenSource;
86pub const parseFromTokenSourceLeaky = @import("json/static.zig").parseFromTokenSourceLeaky;
87pub const innerParse = @import("json/static.zig").innerParse;
88pub const parseFromValue = @import("json/static.zig").parseFromValue;
89pub const parseFromValueLeaky = @import("json/static.zig").parseFromValueLeaky;
90pub const innerParseFromValue = @import("json/static.zig").innerParseFromValue;
91pub const ParseError = @import("json/static.zig").ParseError;
92pub const ParseFromValueError = @import("json/static.zig").ParseFromValueError;
93
94pub const Stringify = @import("json/Stringify.zig");
95
96/// Returns a formatter that formats the given value using stringify.
97pub fn fmt(value: anytype, options: Stringify.Options) Formatter(@TypeOf(value)) {
98 return Formatter(@TypeOf(value)){ .value = value, .options = options };
99}
100
101test fmt {
102 const expectFmt = std.testing.expectFmt;
103 try expectFmt("123", "{f}", .{fmt(@as(u32, 123), .{})});
104 try expectFmt(
105 \\{"num":927,"msg":"hello","sub":{"mybool":true}}
106 , "{f}", .{fmt(struct {
107 num: u32,
108 msg: []const u8,
109 sub: struct {
110 mybool: bool,
111 },
112 }{
113 .num = 927,
114 .msg = "hello",
115 .sub = .{ .mybool = true },
116 }, .{})});
117}
118
119/// Formats the given value using stringify.
120pub fn Formatter(comptime T: type) type {
121 return struct {
122 value: T,
123 options: Stringify.Options,
124
125 pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void {
126 try Stringify.value(self.value, self.options, writer);
127 }
128 };
129}
130
131test {
132 _ = @import("json/test.zig");
133 _ = Scanner;
134 _ = @import("json/dynamic.zig");
135 _ = @import("json/hashmap.zig");
136 _ = @import("json/static.zig");
137 _ = Stringify;
138 _ = @import("json/JSONTestSuite_test.zig");
139}