diff options
Diffstat (limited to 'libphobos/src/std/json.d')
| -rw-r--r-- | libphobos/src/std/json.d | 1031 |
1 files changed, 792 insertions, 239 deletions
diff --git a/libphobos/src/std/json.d b/libphobos/src/std/json.d index 8ba0f05..39f89a6 100644 --- a/libphobos/src/std/json.d +++ b/libphobos/src/std/json.d @@ -6,8 +6,8 @@ JavaScript Object Notation Copyright: Copyright Jeremie Pelletier 2008 - 2009. License: $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0). Authors: Jeremie Pelletier, David Herberth -References: $(LINK http://json.org/) -Source: $(PHOBOSSRC std/_json.d) +References: $(LINK http://json.org/), $(LINK http://seriot.ch/parsing_json.html) +Source: $(PHOBOSSRC std/json.d) */ /* Copyright Jeremie Pelletier 2008 - 2009. @@ -39,7 +39,7 @@ import std.traits; long x; if (const(JSONValue)* code = "code" in j) { - if (code.type() == JSON_TYPE.INTEGER) + if (code.type() == JSONType.integer) x = code.integer; else x = to!int(code.str); @@ -77,31 +77,47 @@ enum JSONOptions specialFloatLiterals = 0x1, /// encode NaN and Inf float values as strings escapeNonAsciiChars = 0x2, /// encode non ascii characters with an unicode escape sequence doNotEscapeSlashes = 0x4, /// do not escape slashes ('/') + strictParsing = 0x8, /// Strictly follow RFC-8259 grammar when parsing } /** JSON type enumeration */ -enum JSON_TYPE : byte +enum JSONType : byte { - /// Indicates the type of a $(D JSONValue). - NULL, - STRING, /// ditto - INTEGER, /// ditto - UINTEGER,/// ditto - FLOAT, /// ditto - OBJECT, /// ditto - ARRAY, /// ditto - TRUE, /// ditto - FALSE /// ditto + /// Indicates the type of a `JSONValue`. + null_, + string, /// ditto + integer, /// ditto + uinteger, /// ditto + float_, /// ditto + array, /// ditto + object, /// ditto + true_, /// ditto + false_, /// ditto + // FIXME: Find some way to deprecate the enum members below, which does NOT + // create lots of spam-like deprecation warnings, which can't be fixed + // by the user. See discussion on this issue at + // https://forum.dlang.org/post/feudrhtxkaxxscwhhhff@forum.dlang.org + /* deprecated("Use .null_") */ NULL = null_, + /* deprecated("Use .string") */ STRING = string, + /* deprecated("Use .integer") */ INTEGER = integer, + /* deprecated("Use .uinteger") */ UINTEGER = uinteger, + /* deprecated("Use .float_") */ FLOAT = float_, + /* deprecated("Use .array") */ ARRAY = array, + /* deprecated("Use .object") */ OBJECT = object, + /* deprecated("Use .true_") */ TRUE = true_, + /* deprecated("Use .false_") */ FALSE = false_, } +deprecated("Use JSONType and the new enum member names") alias JSON_TYPE = JSONType; + /** JSON value node */ struct JSONValue { - import std.exception : enforceEx, enforce; + import std.exception : enforce; union Store { @@ -113,12 +129,12 @@ struct JSONValue JSONValue[] array; } private Store store; - private JSON_TYPE type_tag; + private JSONType type_tag; /** - Returns the JSON_TYPE of the value stored in this structure. + Returns the JSONType of the value stored in this structure. */ - @property JSON_TYPE type() const pure nothrow @safe @nogc + @property JSONType type() const pure nothrow @safe @nogc { return type_tag; } @@ -127,23 +143,23 @@ struct JSONValue { string s = "{ \"language\": \"D\" }"; JSONValue j = parseJSON(s); - assert(j.type == JSON_TYPE.OBJECT); - assert(j["language"].type == JSON_TYPE.STRING); + assert(j.type == JSONType.object); + assert(j["language"].type == JSONType.string); } /*** - * Value getter/setter for $(D JSON_TYPE.STRING). - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.STRING). + * Value getter/setter for `JSONType.string`. + * Throws: `JSONException` for read access if `type` is not + * `JSONType.string`. */ - @property string str() const pure @trusted + @property string str() const pure @trusted return scope { - enforce!JSONException(type == JSON_TYPE.STRING, + enforce!JSONException(type == JSONType.string, "JSONValue is not a string"); return store.str; } /// ditto - @property string str(string v) pure nothrow @nogc @safe + @property string str(return string v) pure nothrow @nogc @trusted return // TODO make @safe { assign(v); return v; @@ -162,13 +178,13 @@ struct JSONValue } /*** - * Value getter/setter for $(D JSON_TYPE.INTEGER). - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.INTEGER). + * Value getter/setter for `JSONType.integer`. + * Throws: `JSONException` for read access if `type` is not + * `JSONType.integer`. */ - @property inout(long) integer() inout pure @safe + @property long integer() const pure @safe { - enforce!JSONException(type == JSON_TYPE.INTEGER, + enforce!JSONException(type == JSONType.integer, "JSONValue is not an integer"); return store.integer; } @@ -180,13 +196,13 @@ struct JSONValue } /*** - * Value getter/setter for $(D JSON_TYPE.UINTEGER). - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.UINTEGER). + * Value getter/setter for `JSONType.uinteger`. + * Throws: `JSONException` for read access if `type` is not + * `JSONType.uinteger`. */ - @property inout(ulong) uinteger() inout pure @safe + @property ulong uinteger() const pure @safe { - enforce!JSONException(type == JSON_TYPE.UINTEGER, + enforce!JSONException(type == JSONType.uinteger, "JSONValue is not an unsigned integer"); return store.uinteger; } @@ -198,14 +214,14 @@ struct JSONValue } /*** - * Value getter/setter for $(D JSON_TYPE.FLOAT). Note that despite + * Value getter/setter for `JSONType.float_`. Note that despite * the name, this is a $(B 64)-bit `double`, not a 32-bit `float`. - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.FLOAT). + * Throws: `JSONException` for read access if `type` is not + * `JSONType.float_`. */ - @property inout(double) floating() inout pure @safe + @property double floating() const pure @safe { - enforce!JSONException(type == JSON_TYPE.FLOAT, + enforce!JSONException(type == JSONType.float_, "JSONValue is not a floating type"); return store.floating; } @@ -217,9 +233,41 @@ struct JSONValue } /*** - * Value getter/setter for $(D JSON_TYPE.OBJECT). - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.OBJECT). + * Value getter/setter for boolean stored in JSON. + * Throws: `JSONException` for read access if `this.type` is not + * `JSONType.true_` or `JSONType.false_`. + */ + @property bool boolean() const pure @safe + { + if (type == JSONType.true_) return true; + if (type == JSONType.false_) return false; + + throw new JSONException("JSONValue is not a boolean type"); + } + /// ditto + @property bool boolean(bool v) pure nothrow @safe @nogc + { + assign(v); + return v; + } + /// + @safe unittest + { + JSONValue j = true; + assert(j.boolean == true); + + j.boolean = false; + assert(j.boolean == false); + + j.integer = 12; + import std.exception : assertThrown; + assertThrown!JSONException(j.boolean); + } + + /*** + * Value getter/setter for `JSONType.object`. + * Throws: `JSONException` for read access if `type` is not + * `JSONType.object`. * Note: this is @system because of the following pattern: --- auto a = &(json.object()); @@ -227,22 +275,22 @@ struct JSONValue (*a)["hello"] = "world"; // segmentation fault --- */ - @property ref inout(JSONValue[string]) object() inout pure @system + @property ref inout(JSONValue[string]) object() inout pure @system return { - enforce!JSONException(type == JSON_TYPE.OBJECT, + enforce!JSONException(type == JSONType.object, "JSONValue is not an object"); return store.object; } /// ditto - @property JSONValue[string] object(JSONValue[string] v) pure nothrow @nogc @safe + @property JSONValue[string] object(return JSONValue[string] v) pure nothrow @nogc @trusted // TODO make @safe { assign(v); return v; } /*** - * Value getter for $(D JSON_TYPE.OBJECT). - * Unlike $(D object), this retrieves the object by value and can be used in @safe code. + * Value getter for `JSONType.object`. + * Unlike `object`, this retrieves the object by value and can be used in @safe code. * * A caveat is that, if the returned value is null, modifications will not be visible: * --- @@ -252,20 +300,20 @@ struct JSONValue * assert("hello" !in json.object); * --- * - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.OBJECT). + * Throws: `JSONException` for read access if `type` is not + * `JSONType.object`. */ @property inout(JSONValue[string]) objectNoRef() inout pure @trusted { - enforce!JSONException(type == JSON_TYPE.OBJECT, + enforce!JSONException(type == JSONType.object, "JSONValue is not an object"); return store.object; } /*** - * Value getter/setter for $(D JSON_TYPE.ARRAY). - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.ARRAY). + * Value getter/setter for `JSONType.array`. + * Throws: `JSONException` for read access if `type` is not + * `JSONType.array`. * Note: this is @system because of the following pattern: --- auto a = &(json.array()); @@ -275,20 +323,20 @@ struct JSONValue */ @property ref inout(JSONValue[]) array() inout pure @system { - enforce!JSONException(type == JSON_TYPE.ARRAY, + enforce!JSONException(type == JSONType.array, "JSONValue is not an array"); return store.array; } /// ditto - @property JSONValue[] array(JSONValue[] v) pure nothrow @nogc @safe + @property JSONValue[] array(return JSONValue[] v) pure nothrow @nogc @trusted scope // TODO make @safe { assign(v); return v; } /*** - * Value getter for $(D JSON_TYPE.ARRAY). - * Unlike $(D array), this retrieves the array by value and can be used in @safe code. + * Value getter for `JSONType.array`. + * Unlike `array`, this retrieves the array by value and can be used in @safe code. * * A caveat is that, if you append to the returned array, the new values aren't visible in the * JSONValue: @@ -299,38 +347,137 @@ struct JSONValue * assert(json.array.length == 1); * --- * - * Throws: $(D JSONException) for read access if $(D type) is not - * $(D JSON_TYPE.ARRAY). + * Throws: `JSONException` for read access if `type` is not + * `JSONType.array`. */ @property inout(JSONValue[]) arrayNoRef() inout pure @trusted { - enforce!JSONException(type == JSON_TYPE.ARRAY, + enforce!JSONException(type == JSONType.array, "JSONValue is not an array"); return store.array; } - /// Test whether the type is $(D JSON_TYPE.NULL) + /// Test whether the type is `JSONType.null_` @property bool isNull() const pure nothrow @safe @nogc { - return type == JSON_TYPE.NULL; + return type == JSONType.null_; } - private void assign(T)(T arg) @safe + /*** + * Generic type value getter + * A convenience getter that returns this `JSONValue` as the specified D type. + * Note: only numeric, `bool`, `string`, `JSONValue[string]` and `JSONValue[]` types are accepted + * Throws: `JSONException` if `T` cannot hold the contents of this `JSONValue` + * `ConvException` in case of integer overflow when converting to `T` + */ + @property inout(T) get(T)() inout const pure @safe + { + static if (is(immutable T == immutable string)) + { + return str; + } + else static if (is(immutable T == immutable bool)) + { + return boolean; + } + else static if (isFloatingPoint!T) + { + switch (type) + { + case JSONType.float_: + return cast(T) floating; + case JSONType.uinteger: + return cast(T) uinteger; + case JSONType.integer: + return cast(T) integer; + default: + throw new JSONException("JSONValue is not a number type"); + } + } + else static if (isIntegral!T) + { + switch (type) + { + case JSONType.uinteger: + return uinteger.to!T; + case JSONType.integer: + return integer.to!T; + default: + throw new JSONException("JSONValue is not a an integral type"); + } + } + else + { + static assert(false, "Unsupported type"); + } + } + // This specialization is needed because arrayNoRef requires inout + @property inout(T) get(T : JSONValue[])() inout pure @trusted /// ditto + { + return arrayNoRef; + } + /// ditto + @property inout(T) get(T : JSONValue[string])() inout pure @trusted + { + return object; + } + /// + @safe unittest + { + import std.exception; + import std.conv; + string s = + `{ + "a": 123, + "b": 3.1415, + "c": "text", + "d": true, + "e": [1, 2, 3], + "f": { "a": 1 }, + "g": -45, + "h": ` ~ ulong.max.to!string ~ `, + }`; + + struct a { } + + immutable json = parseJSON(s); + assert(json["a"].get!double == 123.0); + assert(json["a"].get!int == 123); + assert(json["a"].get!uint == 123); + assert(json["b"].get!double == 3.1415); + assertThrown!JSONException(json["b"].get!int); + assert(json["c"].get!string == "text"); + assert(json["d"].get!bool == true); + assertNotThrown(json["e"].get!(JSONValue[])); + assertNotThrown(json["f"].get!(JSONValue[string])); + static assert(!__traits(compiles, json["a"].get!a)); + assertThrown!JSONException(json["e"].get!float); + assertThrown!JSONException(json["d"].get!(JSONValue[string])); + assertThrown!JSONException(json["f"].get!(JSONValue[])); + assert(json["g"].get!int == -45); + assertThrown!ConvException(json["g"].get!uint); + assert(json["h"].get!ulong == ulong.max); + assertThrown!ConvException(json["h"].get!uint); + assertNotThrown(json["h"].get!float); + } + + private void assign(T)(T arg) { static if (is(T : typeof(null))) { - type_tag = JSON_TYPE.NULL; + type_tag = JSONType.null_; } else static if (is(T : string)) { - type_tag = JSON_TYPE.STRING; + type_tag = JSONType.string; string t = arg; () @trusted { store.str = t; }(); } - else static if (isSomeString!T) // issue 15884 + // https://issues.dlang.org/show_bug.cgi?id=15884 + else static if (isSomeString!T) { - type_tag = JSON_TYPE.STRING; - // FIXME: std.array.array(Range) is not deduced as 'pure' + type_tag = JSONType.string; + // FIXME: std.Array.Array(Range) is not deduced as 'pure' () @trusted { import std.utf : byUTF; store.str = cast(immutable)(arg.byUTF!char.array); @@ -338,27 +485,27 @@ struct JSONValue } else static if (is(T : bool)) { - type_tag = arg ? JSON_TYPE.TRUE : JSON_TYPE.FALSE; + type_tag = arg ? JSONType.true_ : JSONType.false_; } else static if (is(T : ulong) && isUnsigned!T) { - type_tag = JSON_TYPE.UINTEGER; + type_tag = JSONType.uinteger; store.uinteger = arg; } else static if (is(T : long)) { - type_tag = JSON_TYPE.INTEGER; + type_tag = JSONType.integer; store.integer = arg; } else static if (isFloatingPoint!T) { - type_tag = JSON_TYPE.FLOAT; + type_tag = JSONType.float_; store.floating = arg; } else static if (is(T : Value[Key], Key, Value)) { static assert(is(Key : string), "AA key must be string"); - type_tag = JSON_TYPE.OBJECT; + type_tag = JSONType.object; static if (is(Value : JSONValue)) { JSONValue[string] t = arg; @@ -374,7 +521,7 @@ struct JSONValue } else static if (isArray!T) { - type_tag = JSON_TYPE.ARRAY; + type_tag = JSONType.array; static if (is(ElementEncodingType!T : JSONValue)) { JSONValue[] t = arg; @@ -401,7 +548,7 @@ struct JSONValue private void assignRef(T)(ref T arg) if (isStaticArray!T) { - type_tag = JSON_TYPE.ARRAY; + type_tag = JSONType.array; static if (is(ElementEncodingType!T : JSONValue)) { store.array = arg; @@ -416,15 +563,15 @@ struct JSONValue } /** - * Constructor for $(D JSONValue). If $(D arg) is a $(D JSONValue) - * its value and type will be copied to the new $(D JSONValue). - * Note that this is a shallow copy: if type is $(D JSON_TYPE.OBJECT) - * or $(D JSON_TYPE.ARRAY) then only the reference to the data will + * Constructor for `JSONValue`. If `arg` is a `JSONValue` + * its value and type will be copied to the new `JSONValue`. + * Note that this is a shallow copy: if type is `JSONType.object` + * or `JSONType.array` then only the reference to the data will * be copied. - * Otherwise, $(D arg) must be implicitly convertible to one of the - * following types: $(D typeof(null)), $(D string), $(D ulong), - * $(D long), $(D double), an associative array $(D V[K]) for any $(D V) - * and $(D K) i.e. a JSON object, any array or $(D bool). The type will + * Otherwise, `arg` must be implicitly convertible to one of the + * following types: `typeof(null)`, `string`, `ulong`, + * `long`, `double`, an associative array `V[K]` for any `V` + * and `K` i.e. a JSON object, any array or `bool`. The type will * be set accordingly. */ this(T)(T arg) if (!isStaticArray!T) @@ -449,10 +596,10 @@ struct JSONValue j = JSONValue(42); j = JSONValue( [1, 2, 3] ); - assert(j.type == JSON_TYPE.ARRAY); + assert(j.type == JSONType.array); j = JSONValue( ["language": "D"] ); - assert(j.type == JSON_TYPE.OBJECT); + assert(j.type == JSONType.object); } void opAssign(T)(T arg) if (!isStaticArray!T && !is(T : JSONValue)) @@ -467,12 +614,12 @@ struct JSONValue /*** * Array syntax for json arrays. - * Throws: $(D JSONException) if $(D type) is not $(D JSON_TYPE.ARRAY). + * Throws: `JSONException` if `type` is not `JSONType.array`. */ ref inout(JSONValue) opIndex(size_t i) inout pure @safe { auto a = this.arrayNoRef; - enforceEx!JSONException(i < a.length, + enforce!JSONException(i < a.length, "JSONValue array index is out of range"); return a[i]; } @@ -486,9 +633,9 @@ struct JSONValue /*** * Hash syntax for json objects. - * Throws: $(D JSONException) if $(D type) is not $(D JSON_TYPE.OBJECT). + * Throws: `JSONException` if `type` is not `JSONType.object`. */ - ref inout(JSONValue) opIndex(string k) inout pure @safe + ref inout(JSONValue) opIndex(return string k) inout pure @safe { auto o = this.objectNoRef; return *enforce!JSONException(k in o, @@ -502,20 +649,20 @@ struct JSONValue } /*** - * Operator sets $(D value) for element of JSON object by $(D key). + * Operator sets `value` for element of JSON object by `key`. * * If JSON value is null, then operator initializes it with object and then - * sets $(D value) for it. + * sets `value` for it. * - * Throws: $(D JSONException) if $(D type) is not $(D JSON_TYPE.OBJECT) - * or $(D JSON_TYPE.NULL). + * Throws: `JSONException` if `type` is not `JSONType.object` + * or `JSONType.null_`. */ - void opIndexAssign(T)(auto ref T value, string key) pure + void opIndexAssign(T)(auto ref T value, string key) { - enforceEx!JSONException(type == JSON_TYPE.OBJECT || type == JSON_TYPE.NULL, + enforce!JSONException(type == JSONType.object || type == JSONType.null_, "JSONValue must be object or null"); JSONValue[string] aa = null; - if (type == JSON_TYPE.OBJECT) + if (type == JSONType.object) { aa = this.objectNoRef; } @@ -531,10 +678,10 @@ struct JSONValue assert( j["language"].str == "Perl" ); } - void opIndexAssign(T)(T arg, size_t i) pure + void opIndexAssign(T)(T arg, size_t i) { auto a = this.arrayNoRef; - enforceEx!JSONException(i < a.length, + enforce!JSONException(i < a.length, "JSONValue array index is out of range"); a[i] = arg; this.array = a; @@ -547,7 +694,7 @@ struct JSONValue assert( j[1].str == "D" ); } - JSONValue opBinary(string op : "~", T)(T arg) @safe + JSONValue opBinary(string op : "~", T)(T arg) { auto a = this.arrayNoRef; static if (isArray!T) @@ -564,7 +711,7 @@ struct JSONValue } } - void opOpAssign(string op : "~", T)(T arg) @safe + void opOpAssign(string op : "~", T)(T arg) { auto a = this.arrayNoRef; static if (isArray!T) @@ -583,16 +730,16 @@ struct JSONValue } /** - * Support for the $(D in) operator. + * Support for the `in` operator. * * Tests wether a key can be found in an object. * * Returns: - * when found, the $(D const(JSONValue)*) that matches to the key, - * otherwise $(D null). + * when found, the `const(JSONValue)*` that matches to the key, + * otherwise `null`. * - * Throws: $(D JSONException) if the right hand side argument $(D JSON_TYPE) - * is not $(D OBJECT). + * Throws: `JSONException` if the right hand side argument `JSONType` + * is not `object`. */ auto opBinaryRight(string op : "in")(string k) const @safe { @@ -615,30 +762,67 @@ struct JSONValue // Default doesn't work well since store is a union. Compare only // what should be in store. // This is @trusted to remain nogc, nothrow, fast, and usable from @safe code. - if (type_tag != rhs.type_tag) return false; final switch (type_tag) { - case JSON_TYPE.STRING: - return store.str == rhs.store.str; - case JSON_TYPE.INTEGER: - return store.integer == rhs.store.integer; - case JSON_TYPE.UINTEGER: - return store.uinteger == rhs.store.uinteger; - case JSON_TYPE.FLOAT: - return store.floating == rhs.store.floating; - case JSON_TYPE.OBJECT: - return store.object == rhs.store.object; - case JSON_TYPE.ARRAY: - return store.array == rhs.store.array; - case JSON_TYPE.TRUE: - case JSON_TYPE.FALSE: - case JSON_TYPE.NULL: - return true; + case JSONType.integer: + switch (rhs.type_tag) + { + case JSONType.integer: + return store.integer == rhs.store.integer; + case JSONType.uinteger: + return store.integer == rhs.store.uinteger; + case JSONType.float_: + return store.integer == rhs.store.floating; + default: + return false; + } + case JSONType.uinteger: + switch (rhs.type_tag) + { + case JSONType.integer: + return store.uinteger == rhs.store.integer; + case JSONType.uinteger: + return store.uinteger == rhs.store.uinteger; + case JSONType.float_: + return store.uinteger == rhs.store.floating; + default: + return false; + } + case JSONType.float_: + switch (rhs.type_tag) + { + case JSONType.integer: + return store.floating == rhs.store.integer; + case JSONType.uinteger: + return store.floating == rhs.store.uinteger; + case JSONType.float_: + return store.floating == rhs.store.floating; + default: + return false; + } + case JSONType.string: + return type_tag == rhs.type_tag && store.str == rhs.store.str; + case JSONType.object: + return type_tag == rhs.type_tag && store.object == rhs.store.object; + case JSONType.array: + return type_tag == rhs.type_tag && store.array == rhs.store.array; + case JSONType.true_: + case JSONType.false_: + case JSONType.null_: + return type_tag == rhs.type_tag; } } - /// Implements the foreach $(D opApply) interface for json arrays. + /// + @safe unittest + { + assert(JSONValue(0u) == JSONValue(0)); + assert(JSONValue(0u) == JSONValue(0.0)); + assert(JSONValue(0) == JSONValue(0.0)); + } + + /// Implements the foreach `opApply` interface for json arrays. int opApply(scope int delegate(size_t index, ref JSONValue) dg) @system { int result; @@ -653,10 +837,10 @@ struct JSONValue return result; } - /// Implements the foreach $(D opApply) interface for json objects. + /// Implements the foreach `opApply` interface for json objects. int opApply(scope int delegate(string key, ref JSONValue) dg) @system { - enforce!JSONException(type == JSON_TYPE.OBJECT, + enforce!JSONException(type == JSONType.object, "JSONValue is not an object"); int result; @@ -671,7 +855,7 @@ struct JSONValue } /*** - * Implicitly calls $(D toJSON) on this JSONValue. + * Implicitly calls `toJSON` on this JSONValue. * * $(I options) can be used to tweak the conversion behavior. */ @@ -680,8 +864,14 @@ struct JSONValue return toJSON(this, false, options); } + /// + void toString(Out)(Out sink, in JSONOptions options = JSONOptions.none) const + { + toJSON(sink, this, false, options); + } + /*** - * Implicitly calls $(D toJSON) on this JSONValue, like $(D toString), but + * Implicitly calls `toJSON` on this JSONValue, like `toString`, but * also passes $(I true) as $(I pretty) argument. * * $(I options) can be used to tweak the conversion behavior @@ -690,11 +880,47 @@ struct JSONValue { return toJSON(this, true, options); } + + /// + void toPrettyString(Out)(Out sink, in JSONOptions options = JSONOptions.none) const + { + toJSON(sink, this, true, options); + } +} + +// https://issues.dlang.org/show_bug.cgi?id=20874 +@system unittest +{ + static struct MyCustomType + { + public string toString () const @system { return null; } + alias toString this; + } + + static struct B + { + public JSONValue asJSON() const @system { return JSONValue.init; } + alias asJSON this; + } + + if (false) // Just checking attributes + { + JSONValue json; + MyCustomType ilovedlang; + json = ilovedlang; + json["foo"] = ilovedlang; + auto s = ilovedlang in json; + + B b; + json ~= b; + json ~ b; + } } /** Parses a serialized string and returns a tree of JSON values. -Throws: $(LREF JSONException) if the depth exceeds the max depth. +Throws: $(LREF JSONException) if string does not follow the JSON grammar or the depth exceeds the max depth, + $(LREF ConvException) if a number in the input cannot be represented by a native D type. Params: json = json-formatted string to parse maxDepth = maximum depth of nesting allowed, -1 disables depth checking @@ -703,10 +929,10 @@ Params: JSONValue parseJSON(T)(T json, int maxDepth = -1, JSONOptions options = JSONOptions.none) if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) { - import std.ascii : isWhite, isDigit, isHexDigit, toUpper, toLower; - import std.typecons : Yes; + import std.ascii : isDigit, isHexDigit, toUpper, toLower; + import std.typecons : Nullable, Yes; JSONValue root; - root.type_tag = JSON_TYPE.NULL; + root.type_tag = JSONType.null_; // Avoid UTF decoding when possible, as it is unnecessary when // processing JSON. @@ -715,17 +941,37 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) else alias Char = Unqual!(ElementType!T); - if (json.empty) return root; - int depth = -1; - Char next = 0; + Nullable!Char next; int line = 1, pos = 0; + immutable bool strict = (options & JSONOptions.strictParsing) != 0; void error(string msg) { throw new JSONException(msg, line, pos); } + if (json.empty) + { + if (strict) + { + error("Empty JSON body"); + } + return root; + } + + bool isWhite(dchar c) + { + if (strict) + { + // RFC 7159 has a stricter definition of whitespace than general ASCII. + return c == ' ' || c == '\t' || c == '\n' || c == '\r'; + } + import std.ascii : isWhite; + // Accept ASCII NUL as whitespace in non-strict mode. + return c == 0 || isWhite(c); + } + Char popChar() { if (json.empty) error("Unexpected end of data."); @@ -755,17 +1001,35 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) Char peekChar() { - if (!next) + if (next.isNull) { if (json.empty) return '\0'; next = popChar(); } + return next.get; + } + + Nullable!Char peekCharNullable() + { + if (next.isNull && !json.empty) + { + next = popChar(); + } return next; } void skipWhitespace() { - while (isWhite(peekChar())) next = 0; + while (true) + { + auto c = peekCharNullable(); + if (c.isNull || + !isWhite(c.get)) + { + return; + } + next.nullify(); + } } Char getChar(bool SkipWhitespace = false)() @@ -773,10 +1037,10 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) static if (SkipWhitespace) skipWhitespace(); Char c; - if (next) + if (!next.isNull) { - c = next; - next = 0; + c = next.get; + next.nullify(); } else c = popChar(); @@ -784,11 +1048,11 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) return c; } - void checkChar(bool SkipWhitespace = true, bool CaseSensitive = true)(char c) + void checkChar(bool SkipWhitespace = true)(char c, bool caseSensitive = true) { static if (SkipWhitespace) skipWhitespace(); auto c2 = getChar(); - static if (!CaseSensitive) c2 = toLower(c2); + if (!caseSensitive) c2 = toLower(c2); if (c2 != c) error(text("Found '", c2, "' when expecting '", c, "'.")); } @@ -819,7 +1083,6 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) string parseString() { - import std.ascii : isControl; import std.uni : isSurrogateHi, isSurrogateLo; import std.utf : encode, decode; @@ -880,8 +1143,12 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) default: // RFC 7159 states that control characters U+0000 through // U+001F must not appear unescaped in a JSON string. + // Note: std.ascii.isControl can't be used for this test + // because it considers ASCII DEL (0x7f) to be a control + // character but RFC 7159 does not. + // Accept unescaped ASCII NULs in non-strict mode. auto c = getChar(); - if (isControl(c)) + if (c < 0x20 && (strict || c != 0)) error("Illegal control character."); str.put(c); goto Next; @@ -927,6 +1194,11 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) JSONValue[string] obj; do { + skipWhitespace(); + if (!strict && peekChar() == '}') + { + break; + } checkChar('"'); string name = parseString(); checkChar(':'); @@ -943,13 +1215,18 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) case '[': if (testChar(']')) { - value.type_tag = JSON_TYPE.ARRAY; + value.type_tag = JSONType.array; break; } JSONValue[] arr; do { + skipWhitespace(); + if (!strict && peekChar() == ']') + { + break; + } JSONValue element; parseValue(element); arr ~= element; @@ -968,12 +1245,11 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) tryGetSpecialFloat(str, value.store.floating)) { // found a special float, its value was placed in value.store.floating - value.type_tag = JSON_TYPE.FLOAT; + value.type_tag = JSONType.float_; break; } - value.type_tag = JSON_TYPE.STRING; - value.store.str = str; + value.assign(str); break; case '0': .. case '9': @@ -1001,7 +1277,18 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) isNegative = true; } - readInteger(); + if (strict && c == '0') + { + number.put('0'); + if (isDigit(peekChar())) + { + error("Additional digits not allowed after initial zero digit"); + } + } + else + { + readInteger(); + } if (testChar('.')) { @@ -1023,44 +1310,63 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) string data = number.data; if (isFloat) { - value.type_tag = JSON_TYPE.FLOAT; + value.type_tag = JSONType.float_; value.store.floating = parse!double(data); } else { if (isNegative) + { value.store.integer = parse!long(data); + value.type_tag = JSONType.integer; + } else - value.store.uinteger = parse!ulong(data); - - value.type_tag = !isNegative && value.store.uinteger & (1UL << 63) ? - JSON_TYPE.UINTEGER : JSON_TYPE.INTEGER; + { + // only set the correct union member to not confuse CTFE + ulong u = parse!ulong(data); + if (u & (1UL << 63)) + { + value.store.uinteger = u; + value.type_tag = JSONType.uinteger; + } + else + { + value.store.integer = u; + value.type_tag = JSONType.integer; + } + } } break; - case 't': case 'T': - value.type_tag = JSON_TYPE.TRUE; - checkChar!(false, false)('r'); - checkChar!(false, false)('u'); - checkChar!(false, false)('e'); + if (strict) goto default; + goto case; + case 't': + value.type_tag = JSONType.true_; + checkChar!false('r', strict); + checkChar!false('u', strict); + checkChar!false('e', strict); break; - case 'f': case 'F': - value.type_tag = JSON_TYPE.FALSE; - checkChar!(false, false)('a'); - checkChar!(false, false)('l'); - checkChar!(false, false)('s'); - checkChar!(false, false)('e'); + if (strict) goto default; + goto case; + case 'f': + value.type_tag = JSONType.false_; + checkChar!false('a', strict); + checkChar!false('l', strict); + checkChar!false('s', strict); + checkChar!false('e', strict); break; - case 'n': case 'N': - value.type_tag = JSON_TYPE.NULL; - checkChar!(false, false)('u'); - checkChar!(false, false)('l'); - checkChar!(false, false)('l'); + if (strict) goto default; + goto case; + case 'n': + value.type_tag = JSONType.null_; + checkChar!false('u', strict); + checkChar!false('l', strict); + checkChar!false('l', strict); break; default: @@ -1071,16 +1377,21 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) } parseValue(root); + if (strict) + { + skipWhitespace(); + if (!peekCharNullable().isNull) error("Trailing non-whitespace characters"); + } return root; } @safe unittest { enum issue15742objectOfObject = `{ "key1": { "key2": 1 }}`; - static assert(parseJSON(issue15742objectOfObject).type == JSON_TYPE.OBJECT); + static assert(parseJSON(issue15742objectOfObject).type == JSONType.object); enum issue15742arrayOfArray = `[[1]]`; - static assert(parseJSON(issue15742arrayOfArray).type == JSON_TYPE.ARRAY); + static assert(parseJSON(issue15742arrayOfArray).type == JSONType.array); } @safe unittest @@ -1110,9 +1421,15 @@ if (isInputRange!T && !isInfinite!T && isSomeChar!(ElementEncodingType!T)) assert(json["key1"]["key2"].integer == 1); } +// https://issues.dlang.org/show_bug.cgi?id=20527 +@safe unittest +{ + static assert(parseJSON(`{"a" : 2}`)["a"].integer == 2); +} + /** Parses a serialized string and returns a tree of JSON values. -Throws: $(REF JSONException, std,json) if the depth exceeds the max depth. +Throws: $(LREF JSONException) if the depth exceeds the max depth. Params: json = json-formatted string to parse options = enable decoding string representations of NaN/Inf as float values @@ -1128,15 +1445,26 @@ Takes a tree of JSON values and returns the serialized string. Any Object types will be serialized in a key-sorted order. -If $(D pretty) is false no whitespaces are generated. -If $(D pretty) is true serialized string is formatted to be human-readable. -Set the $(LREF JSONOptions.specialFloatLiterals) flag is set in $(D options) to encode NaN/Infinity as strings. +If `pretty` is false no whitespaces are generated. +If `pretty` is true serialized string is formatted to be human-readable. +Set the $(LREF JSONOptions.specialFloatLiterals) flag is set in `options` to encode NaN/Infinity as strings. */ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions options = JSONOptions.none) @safe { auto json = appender!string(); + toJSON(json, root, pretty, options); + return json.data; +} - void toStringImpl(Char)(string str) @safe +/// +void toJSON(Out)( + auto ref Out json, + const ref JSONValue root, + in bool pretty = false, + in JSONOptions options = JSONOptions.none) +if (isOutputRange!(Out,char)) +{ + void toStringImpl(Char)(string str) { json.put('"'); @@ -1166,7 +1494,7 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o // Make sure we do UTF decoding iff we want to // escape Unicode characters. assert(((options & JSONOptions.escapeNonAsciiChars) != 0) - == is(Char == dchar)); + == is(Char == dchar), "JSONOptions.escapeNonAsciiChars needs dchar strings"); with (JSONOptions) if (isControl(c) || ((options & escapeNonAsciiChars) >= escapeNonAsciiChars && c >= 0x80)) @@ -1197,7 +1525,7 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o json.put('"'); } - void toString(string str) @safe + void toString(string str) { // Avoid UTF decoding when possible, as it is unnecessary when // processing JSON. @@ -1207,7 +1535,19 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o toStringImpl!char(str); } - void toValue(ref in JSONValue value, ulong indentLevel) @safe + // recursive @safe inference is broken here + // workaround: if json.put is @safe, we should be too, + // so annotate the recursion as @safe manually + static if (isSafe!({ json.put(""); })) + { + void delegate(ref const JSONValue, ulong) @safe toValue; + } + else + { + void delegate(ref const JSONValue, ulong) @system toValue; + } + + void toValueImpl(ref const JSONValue value, ulong indentLevel) { void putTabs(ulong additionalIndent = 0) { @@ -1228,7 +1568,7 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o final switch (value.type) { - case JSON_TYPE.OBJECT: + case JSONType.object: auto obj = value.objectNoRef; if (!obj.length) { @@ -1257,7 +1597,7 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o } import std.algorithm.sorting : sort; - // @@@BUG@@@ 14439 + // https://issues.dlang.org/show_bug.cgi?id=14439 // auto names = obj.keys; // aa.keys can't be called in @safe code auto names = new string[obj.length]; size_t i = 0; @@ -1275,7 +1615,7 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o } break; - case JSON_TYPE.ARRAY: + case JSONType.array: auto arr = value.arrayNoRef; if (arr.empty) { @@ -1297,20 +1637,20 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o } break; - case JSON_TYPE.STRING: + case JSONType.string: toString(value.str); break; - case JSON_TYPE.INTEGER: + case JSONType.integer: json.put(to!string(value.store.integer)); break; - case JSON_TYPE.UINTEGER: + case JSONType.uinteger: json.put(to!string(value.store.uinteger)); break; - case JSON_TYPE.FLOAT: - import std.math : isNaN, isInfinity; + case JSONType.float_: + import std.math.traits : isNaN, isInfinity; auto val = value.store.floating; @@ -1340,34 +1680,41 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o } else { - import std.format : format; + import std.algorithm.searching : canFind; + import std.format : sformat; // The correct formula for the number of decimal digits needed for lossless round // trips is actually: // ceil(log(pow(2.0, double.mant_dig - 1)) / log(10.0) + 1) == (double.dig + 2) // Anything less will round off (1 + double.epsilon) - json.put("%.18g".format(val)); + char[25] buf; + auto result = buf[].sformat!"%.18g"(val); + json.put(result); + if (!result.canFind('e') && !result.canFind('.')) + json.put(".0"); } break; - case JSON_TYPE.TRUE: + case JSONType.true_: json.put("true"); break; - case JSON_TYPE.FALSE: + case JSONType.false_: json.put("false"); break; - case JSON_TYPE.NULL: + case JSONType.null_: json.put("null"); break; } } + toValue = &toValueImpl; + toValue(root, 0); - return json.data; } -@safe unittest // bugzilla 12897 + // https://issues.dlang.org/show_bug.cgi?id=12897 +@safe unittest { JSONValue jv0 = JSONValue("test测试"); assert(toJSON(jv0, false, JSONOptions.escapeNonAsciiChars) == `"test\u6D4B\u8BD5"`); @@ -1381,6 +1728,71 @@ string toJSON(const ref JSONValue root, in bool pretty = false, in JSONOptions o assert(toJSON(jv1, false, JSONOptions.none) == `"été"`); } +// https://issues.dlang.org/show_bug.cgi?id=20511 +@system unittest +{ + import std.format.write : formattedWrite; + import std.range : nullSink, outputRangeObject; + + outputRangeObject!(const(char)[])(nullSink) + .formattedWrite!"%s"(JSONValue.init); +} + +// Issue 16432 - JSON incorrectly parses to string +@safe unittest +{ + // Floating points numbers are rounded to the nearest integer and thus get + // incorrectly parsed + + import std.math.operations : isClose; + + string s = "{\"rating\": 3.0 }"; + JSONValue j = parseJSON(s); + assert(j["rating"].type == JSONType.float_); + j = j.toString.parseJSON; + assert(j["rating"].type == JSONType.float_); + assert(isClose(j["rating"].floating, 3.0)); + + s = "{\"rating\": -3.0 }"; + j = parseJSON(s); + assert(j["rating"].type == JSONType.float_); + j = j.toString.parseJSON; + assert(j["rating"].type == JSONType.float_); + assert(isClose(j["rating"].floating, -3.0)); + + // https://issues.dlang.org/show_bug.cgi?id=13660 + auto jv1 = JSONValue(4.0); + auto textual = jv1.toString(); + auto jv2 = parseJSON(textual); + assert(jv1.type == JSONType.float_); + assert(textual == "4.0"); + assert(jv2.type == JSONType.float_); +} + +@safe unittest +{ + // Adapted from https://github.com/dlang/phobos/pull/5005 + // Result from toString is not checked here, because this + // might differ (%e-like or %f-like output) depending + // on OS and compiler optimization. + import std.math.operations : isClose; + + // test positive extreme values + JSONValue j; + j["rating"] = 1e18 - 65; + assert(isClose(j.toString.parseJSON["rating"].floating, 1e18 - 65)); + + j["rating"] = 1e18 - 64; + assert(isClose(j.toString.parseJSON["rating"].floating, 1e18 - 64)); + + // negative extreme values + j["rating"] = -1e18 + 65; + assert(isClose(j.toString.parseJSON["rating"].floating, -1e18 + 65)); + + j["rating"] = -1e18 + 64; + assert(isClose(j.toString.parseJSON["rating"].floating, -1e18 + 64)); +} + /** Exception thrown on JSON errors */ @@ -1405,7 +1817,7 @@ class JSONException : Exception { import std.exception; JSONValue jv = "123"; - assert(jv.type == JSON_TYPE.STRING); + assert(jv.type == JSONType.string); assertNotThrown(jv.str); assertThrown!JSONException(jv.integer); assertThrown!JSONException(jv.uinteger); @@ -1416,19 +1828,19 @@ class JSONException : Exception assertThrown!JSONException(jv[2]); jv = -3; - assert(jv.type == JSON_TYPE.INTEGER); + assert(jv.type == JSONType.integer); assertNotThrown(jv.integer); jv = cast(uint) 3; - assert(jv.type == JSON_TYPE.UINTEGER); + assert(jv.type == JSONType.uinteger); assertNotThrown(jv.uinteger); jv = 3.0; - assert(jv.type == JSON_TYPE.FLOAT); + assert(jv.type == JSONType.float_); assertNotThrown(jv.floating); jv = ["key" : "value"]; - assert(jv.type == JSON_TYPE.OBJECT); + assert(jv.type == JSONType.object); assertNotThrown(jv.object); assertNotThrown(jv["key"]); assert("key" in jv); @@ -1442,82 +1854,81 @@ class JSONException : Exception { static assert(is(typeof(value) == JSONValue)); assert(key == "key"); - assert(value.type == JSON_TYPE.STRING); + assert(value.type == JSONType.string); assertNotThrown(value.str); assert(value.str == "value"); } jv = [3, 4, 5]; - assert(jv.type == JSON_TYPE.ARRAY); + assert(jv.type == JSONType.array); assertNotThrown(jv.array); assertNotThrown(jv[2]); foreach (size_t index, value; jv) { static assert(is(typeof(value) == JSONValue)); - assert(value.type == JSON_TYPE.INTEGER); + assert(value.type == JSONType.integer); assertNotThrown(value.integer); assert(index == (value.integer-3)); } jv = null; - assert(jv.type == JSON_TYPE.NULL); + assert(jv.type == JSONType.null_); assert(jv.isNull); jv = "foo"; assert(!jv.isNull); jv = JSONValue("value"); - assert(jv.type == JSON_TYPE.STRING); + assert(jv.type == JSONType.string); assert(jv.str == "value"); JSONValue jv2 = JSONValue("value"); - assert(jv2.type == JSON_TYPE.STRING); + assert(jv2.type == JSONType.string); assert(jv2.str == "value"); JSONValue jv3 = JSONValue("\u001c"); - assert(jv3.type == JSON_TYPE.STRING); + assert(jv3.type == JSONType.string); assert(jv3.str == "\u001C"); } +// https://issues.dlang.org/show_bug.cgi?id=11504 @system unittest { - // Bugzilla 11504 - JSONValue jv = 1; - assert(jv.type == JSON_TYPE.INTEGER); + assert(jv.type == JSONType.integer); jv.str = "123"; - assert(jv.type == JSON_TYPE.STRING); + assert(jv.type == JSONType.string); assert(jv.str == "123"); jv.integer = 1; - assert(jv.type == JSON_TYPE.INTEGER); + assert(jv.type == JSONType.integer); assert(jv.integer == 1); jv.uinteger = 2u; - assert(jv.type == JSON_TYPE.UINTEGER); + assert(jv.type == JSONType.uinteger); assert(jv.uinteger == 2u); jv.floating = 1.5; - assert(jv.type == JSON_TYPE.FLOAT); + assert(jv.type == JSONType.float_); assert(jv.floating == 1.5); jv.object = ["key" : JSONValue("value")]; - assert(jv.type == JSON_TYPE.OBJECT); + assert(jv.type == JSONType.object); assert(jv.object == ["key" : JSONValue("value")]); jv.array = [JSONValue(1), JSONValue(2), JSONValue(3)]; - assert(jv.type == JSON_TYPE.ARRAY); + assert(jv.type == JSONType.array); assert(jv.array == [JSONValue(1), JSONValue(2), JSONValue(3)]); jv = true; - assert(jv.type == JSON_TYPE.TRUE); + assert(jv.type == JSONType.true_); jv = false; - assert(jv.type == JSON_TYPE.FALSE); + assert(jv.type == JSONType.false_); enum E{True = true} jv = E.True; - assert(jv.type == JSON_TYPE.TRUE); + assert(jv.type == JSONType.true_); } @system pure unittest @@ -1653,32 +2064,32 @@ class JSONException : Exception @system pure unittest { - // Bugzilla 12969 + // https://issues.dlang.org/show_bug.cgi?id=12969 JSONValue jv; jv["int"] = 123; - assert(jv.type == JSON_TYPE.OBJECT); + assert(jv.type == JSONType.object); assert("int" in jv); assert(jv["int"].integer == 123); jv["array"] = [1, 2, 3, 4, 5]; - assert(jv["array"].type == JSON_TYPE.ARRAY); + assert(jv["array"].type == JSONType.array); assert(jv["array"][2].integer == 3); jv["str"] = "D language"; - assert(jv["str"].type == JSON_TYPE.STRING); + assert(jv["str"].type == JSONType.string); assert(jv["str"].str == "D language"); jv["bool"] = false; - assert(jv["bool"].type == JSON_TYPE.FALSE); + assert(jv["bool"].type == JSONType.false_); assert(jv.object.length == 4); jv = [5, 4, 3, 2, 1]; - assert( jv.type == JSON_TYPE.ARRAY ); - assert( jv[3].integer == 2 ); + assert(jv.type == JSONType.array); + assert(jv[3].integer == 2); } @safe unittest @@ -1702,7 +2113,7 @@ EOF"; @safe unittest { import std.exception : assertThrown; - import std.math : isNaN, isInfinity; + import std.math.traits : isNaN, isInfinity; // expected representations of NaN and Inf enum { @@ -1753,28 +2164,30 @@ pure nothrow @safe @nogc unittest assert(testVal.isNull); } -pure nothrow @safe unittest // issue 15884 +// https://issues.dlang.org/show_bug.cgi?id=15884 +pure nothrow @safe unittest { import std.typecons; void Test(C)() { C[] a = ['x']; JSONValue testVal = a; - assert(testVal.type == JSON_TYPE.STRING); + assert(testVal.type == JSONType.string); testVal = a.idup; - assert(testVal.type == JSON_TYPE.STRING); + assert(testVal.type == JSONType.string); } Test!char(); Test!wchar(); Test!dchar(); } -@safe unittest // issue 15885 +// https://issues.dlang.org/show_bug.cgi?id=15885 +@safe unittest { enum bool realInDoublePrecision = real.mant_dig == double.mant_dig; static bool test(const double num0) { - import std.math : feqrel; + import std.math.operations : feqrel; const json0 = JSONValue(num0); const num1 = to!double(toJSON(json0)); static if (realInDoublePrecision) @@ -1802,34 +2215,39 @@ pure nothrow @safe unittest // issue 15884 assert(test(3*minSub)); } -@safe unittest // issue 17555 +// https://issues.dlang.org/show_bug.cgi?id=17555 +@safe unittest { import std.exception : assertThrown; assertThrown!JSONException(parseJSON("\"a\nb\"")); } -@safe unittest // issue 17556 +// https://issues.dlang.org/show_bug.cgi?id=17556 +@safe unittest { auto v = JSONValue("\U0001D11E"); auto j = toJSON(v, false, JSONOptions.escapeNonAsciiChars); assert(j == `"\uD834\uDD1E"`); } -@safe unittest // issue 5904 +// https://issues.dlang.org/show_bug.cgi?id=5904 +@safe unittest { string s = `"\uD834\uDD1E"`; auto j = parseJSON(s); assert(j.str == "\U0001D11E"); } -@safe unittest // issue 17557 +// https://issues.dlang.org/show_bug.cgi?id=17557 +@safe unittest { assert(parseJSON("\"\xFF\"").str == "\xFF"); assert(parseJSON("\"\U0001D11E\"").str == "\U0001D11E"); } -@safe unittest // issue 17553 +// https://issues.dlang.org/show_bug.cgi?id=17553 +@safe unittest { auto v = JSONValue("\xFF"); assert(toJSON(v) == "\"\xFF\""); @@ -1842,10 +2260,145 @@ pure nothrow @safe unittest // issue 15884 assert(parseJSON("\"\U0001D11E\"".byChar).str == "\U0001D11E"); } -@safe unittest // JSONOptions.doNotEscapeSlashes (issue 17587) +// JSONOptions.doNotEscapeSlashes (https://issues.dlang.org/show_bug.cgi?id=17587) +@safe unittest { assert(parseJSON(`"/"`).toString == `"\/"`); assert(parseJSON(`"\/"`).toString == `"\/"`); assert(parseJSON(`"/"`).toString(JSONOptions.doNotEscapeSlashes) == `"/"`); assert(parseJSON(`"\/"`).toString(JSONOptions.doNotEscapeSlashes) == `"/"`); } + +// JSONOptions.strictParsing (https://issues.dlang.org/show_bug.cgi?id=16639) +@safe unittest +{ + import std.exception : assertThrown; + + // Unescaped ASCII NULs + assert(parseJSON("[\0]").type == JSONType.array); + assertThrown!JSONException(parseJSON("[\0]", JSONOptions.strictParsing)); + assert(parseJSON("\"\0\"").str == "\0"); + assertThrown!JSONException(parseJSON("\"\0\"", JSONOptions.strictParsing)); + + // Unescaped ASCII DEL (0x7f) in strings + assert(parseJSON("\"\x7f\"").str == "\x7f"); + assert(parseJSON("\"\x7f\"", JSONOptions.strictParsing).str == "\x7f"); + + // "true", "false", "null" case sensitivity + assert(parseJSON("true").type == JSONType.true_); + assert(parseJSON("true", JSONOptions.strictParsing).type == JSONType.true_); + assert(parseJSON("True").type == JSONType.true_); + assertThrown!JSONException(parseJSON("True", JSONOptions.strictParsing)); + assert(parseJSON("tRUE").type == JSONType.true_); + assertThrown!JSONException(parseJSON("tRUE", JSONOptions.strictParsing)); + + assert(parseJSON("false").type == JSONType.false_); + assert(parseJSON("false", JSONOptions.strictParsing).type == JSONType.false_); + assert(parseJSON("False").type == JSONType.false_); + assertThrown!JSONException(parseJSON("False", JSONOptions.strictParsing)); + assert(parseJSON("fALSE").type == JSONType.false_); + assertThrown!JSONException(parseJSON("fALSE", JSONOptions.strictParsing)); + + assert(parseJSON("null").type == JSONType.null_); + assert(parseJSON("null", JSONOptions.strictParsing).type == JSONType.null_); + assert(parseJSON("Null").type == JSONType.null_); + assertThrown!JSONException(parseJSON("Null", JSONOptions.strictParsing)); + assert(parseJSON("nULL").type == JSONType.null_); + assertThrown!JSONException(parseJSON("nULL", JSONOptions.strictParsing)); + + // Whitespace characters + assert(parseJSON("[\f\v]").type == JSONType.array); + assertThrown!JSONException(parseJSON("[\f\v]", JSONOptions.strictParsing)); + assert(parseJSON("[ \t\r\n]").type == JSONType.array); + assert(parseJSON("[ \t\r\n]", JSONOptions.strictParsing).type == JSONType.array); + + // Empty input + assert(parseJSON("").type == JSONType.null_); + assertThrown!JSONException(parseJSON("", JSONOptions.strictParsing)); + + // Numbers with leading '0's + assert(parseJSON("01").integer == 1); + assertThrown!JSONException(parseJSON("01", JSONOptions.strictParsing)); + assert(parseJSON("-01").integer == -1); + assertThrown!JSONException(parseJSON("-01", JSONOptions.strictParsing)); + assert(parseJSON("0.01").floating == 0.01); + assert(parseJSON("0.01", JSONOptions.strictParsing).floating == 0.01); + assert(parseJSON("0e1").floating == 0); + assert(parseJSON("0e1", JSONOptions.strictParsing).floating == 0); + + // Trailing characters after JSON value + assert(parseJSON(`""asdf`).str == ""); + assertThrown!JSONException(parseJSON(`""asdf`, JSONOptions.strictParsing)); + assert(parseJSON("987\0").integer == 987); + assertThrown!JSONException(parseJSON("987\0", JSONOptions.strictParsing)); + assert(parseJSON("987\0\0").integer == 987); + assertThrown!JSONException(parseJSON("987\0\0", JSONOptions.strictParsing)); + assert(parseJSON("[]]").type == JSONType.array); + assertThrown!JSONException(parseJSON("[]]", JSONOptions.strictParsing)); + assert(parseJSON("123 \t\r\n").integer == 123); // Trailing whitespace is OK + assert(parseJSON("123 \t\r\n", JSONOptions.strictParsing).integer == 123); +} + +@system unittest +{ + import std.algorithm.iteration : map; + import std.array : array; + import std.exception : assertThrown; + + string s = `{ "a" : [1,2,3,], }`; + JSONValue j = parseJSON(s); + assert(j["a"].array().map!(i => i.integer()).array == [1,2,3]); + + assertThrown(parseJSON(s, -1, JSONOptions.strictParsing)); +} + +@system unittest +{ + import std.algorithm.iteration : map; + import std.array : array; + import std.exception : assertThrown; + + string s = `{ "a" : { } , }`; + JSONValue j = parseJSON(s); + assert("a" in j); + auto t = j["a"].object(); + assert(t.empty); + + assertThrown(parseJSON(s, -1, JSONOptions.strictParsing)); +} + +// https://issues.dlang.org/show_bug.cgi?id=20330 +@safe unittest +{ + import std.array : appender; + + string s = `{"a":[1,2,3]}`; + JSONValue j = parseJSON(s); + + auto app = appender!string(); + j.toString(app); + + assert(app.data == s, app.data); +} + +// https://issues.dlang.org/show_bug.cgi?id=20330 +@safe unittest +{ + import std.array : appender; + import std.format.write : formattedWrite; + + string s = +`{ + "a": [ + 1, + 2, + 3 + ] +}`; + JSONValue j = parseJSON(s); + + auto app = appender!string(); + j.toPrettyString(app); + + assert(app.data == s, app.data); +} |