1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2014 Alexis Laferrière <alexis.laf@xymus.net>
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
17 # Dynamic interface to read JSON strings.
19 # `String::to_json_value` returns a `JsonValue` which can be queried
20 # to get the underlying JSON data.
28 # Offer methods to query the type, to dynamicaly cast the underlying value and
29 # to query elements (in case of a JSON object or a JSON array).
31 # Use `String::to_json_value` to get a `JsonValue` from a string.
34 # The wrapped JSON value.
35 var value
: nullable Object
39 # assert "null".to_json_value.is_null
40 # assert not "123".to_json_value.is_null
41 fun is_null
: Bool do return value
== null
43 # Is this value an integer?
45 # assert "123".to_json_value.is_int
46 # assert not "1.23".to_json_value.is_int
47 # assert not "\"str\"".to_json_value.is_int
48 fun is_int
: Bool do return value
isa Int
50 # Get this value as a `Int`
52 # require: `self.is_int`
54 # assert "-10".to_json_value.to_i == -10
55 # assert "123".to_json_value.to_i == 123
56 fun to_i
: Int do return value
.as(Int)
58 # Is this value a float?
60 # assert "0.0".to_json_value.is_float
61 # assert "123.456".to_json_value.is_float
62 # assert not "123".to_json_value.is_float
63 fun is_float
: Bool do return value
isa Float
65 # Get this value as a `Float`
67 # require: `self.is_float`
69 # assert "0.0".to_json_value.to_f == 0.0
70 # assert "123.456".to_json_value.to_f == 123.456
71 fun to_f
: Float do return value
.as(Float)
73 # Is the value numeric?
75 # assert "1.234".to_json_value.is_numeric
76 # assert "1234".to_json_value.is_numeric
77 # assert not "\"str\"".to_json_value.is_numeric
78 # assert not "1.2.3.4".to_json_value.is_numeric
79 fun is_numeric
: Bool do return is_int
or is_float
81 # Get this value as a `Numeric`
83 # require: `self.is_numeric`
85 # assert "1.234".to_json_value.to_numeric == 1.234
86 # assert "1234".to_json_value.to_numeric == 1234
87 fun to_numeric
: Numeric
89 if is_int
then return to_i
93 # Is this value a boolean?
95 # assert "true".to_json_value.is_bool
96 # assert "false".to_json_value.is_bool
97 fun is_bool
: Bool do return value
isa Bool
99 # Get this value as a `Bool`
101 # require: `self.is_bool`
103 # assert "true".to_json_value.to_bool
104 # assert not "false".to_json_value.to_bool
105 fun to_bool
: Bool do return value
.as(Bool)
107 # Is this value a string?
109 # assert "\"str\"".to_json_value.is_string
110 # assert not "123".to_json_value.is_string
111 fun is_string
: Bool do return value
isa String
113 # Get this value as a `String`
115 # If value is null, return "null", otherwise returns `value.to_s`. It is practical
116 # on most types, except maps which does not have a custom `to_s`.
118 # assert "\"str\"".to_json_value.to_s == "str"
119 # assert "123".to_json_value.to_s == "123"
120 # assert "true".to_json_value.to_s == "true"
121 # assert "[1, 2, 3]".to_json_value.to_s == "123"
122 redef fun to_s
: String
124 if value
== null then return "null"
130 # Is this value a Json object (a map)?
132 # assert """{"a": 123}""".to_json_value.is_map
133 # assert not "123".to_json_value.is_map
134 fun is_map
: Bool do return value
isa MapRead[String, nullable Object]
136 # Get this value as a `Map[String, JsonValue]`
138 # require: `self.is_map`
139 fun to_map
: Map[String, JsonValue] do
141 assert value
isa MapRead[String, nullable Object]
143 var map
= new HashMap[String, JsonValue]
144 for k
, v
in value
do map
[k
] = new JsonValue(v
)
150 # Is this value an array?
152 # assert "[]".to_json_value.is_array
153 # assert "[1, 2, 3, 4, 5]".to_json_value.is_array
154 # assert "[null, true, false, 0.0, 1, \"str\"]".to_json_value.is_array
155 # assert """["a", "b", "c"]""".to_json_value.is_array
156 fun is_array
: Bool do return value
isa SequenceRead[nullable Object]
158 # Get this value as an `Array[JsonValue]`
160 # require: `self.is_array`
162 # assert """["a", "b", "c"]""".to_json_value.to_a.join(", ") == "a, b, c"
163 fun to_a
: Array[JsonValue]
166 assert value
isa SequenceRead[nullable Object]
168 var a
= new Array[JsonValue]
169 for e
in value
do a
.add
(new JsonValue(e
))
175 # Is this value an error?
177 # assert "[]".to_json_value[0].is_error
178 # assert "[".to_json_value.is_error
179 # assert not "[]".to_json_value.is_error
180 fun is_error
: Bool do return value
isa Error
182 # Get this value as a `Error`.
184 # require: `self.is_error`
185 fun to_error
: Error do return value
.as(Error)
189 # Is this value a parse error?
191 # assert "[".to_json_value.is_parse_error
192 # assert not "[]".to_json_value.is_parse_error
193 fun is_parse_error
: Bool do return value
isa JsonParseError
195 # Get this value as a `JsonParseError`.
197 # require: `self.is_parse_error`
198 fun to_parse_error
: JsonParseError do return value
.as(JsonParseError)
202 # Iterator over the values of the array `self`
204 # require: `self.is_array`
206 # var a = new Array[String]
207 # for e in """["a", "b", "c"]""".to_json_value do a.add(e.to_s)
211 fun iterator
: Iterator[JsonValue] do return to_a
.iterator
213 # Get value at index `key` on the array or map `self`
215 # require: `self.is_array or self.is_map`
216 # require: `self.is_array implies key isa Int`
218 # assert """{"a": 123}""".to_json_value["a"].to_i == 123
219 # assert """{"123": "a"}""".to_json_value[123].to_s == "a"
220 # assert """{"John Smith": 1980}""".to_json_value[["John ", "Smith"]].to_i == 1980
221 # assert """{"a": 123}""".to_json_value["b"].is_error
223 # assert """["a", "b", "c"]""".to_json_value[0].to_s == "a"
224 # assert """["a", "b", "c"]""".to_json_value[3].is_error
225 fun [](key
: Object): JsonValue do
227 var result
: nullable Object
230 else if value
isa MapRead[String, nullable Object] then
232 if value
.has_key
(key
) then
235 result
= new JsonKeyError("Key `{key}` not found.", self, key
)
237 else if value
isa SequenceRead[nullable Object] then
239 if key
< value
.length
and key
>= 0 then
242 result
= new JsonKeyError("Index `{key}` out of bounds.",
246 result
= new JsonKeyError("Invalid key type. Expecting `Int`. Got `{key.class_name}`.",
250 result
= new JsonKeyError("Invalid `[]` access on a `{json_type}` JsonValue.",
253 return new JsonValue(result
)
256 # Advanced query to get a value within the map `self` or it's children.
258 # A query is composed of the keys to each map seperated by '.'.
260 # require: `self.is_map`
262 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a").is_map
263 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t").to_bool
264 # assert not """{"a": {"t": true, "f": false}}""".to_json_value.get("a.f").to_bool
265 # assert """{"a": {"t": true, "f": false}}""".to_json_value.get("a.t.t").is_error
266 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.b.c.d").to_i == 123
267 # assert """{"a": {"b": {"c": {"d": 123}}}}""".to_json_value.get("a.z.c.d").is_error
268 fun get
(query
: String): JsonValue do
269 var keys
= query
.split
(".")
271 if is_error
then return self
272 for i
in [0..keys
.length
[ do
274 if value
isa MapRead[String, nullable Object] then
275 if value
.has_key
(key
) then
278 var sub_query
= sub_query_to_s
(keys
, i
)
279 var e
= new JsonKeyError("Key `{key}` not found.",
281 return new JsonValue(e
)
284 var sub_query
= sub_query_to_s
(keys
, i
)
285 var val_type
= (new JsonValue(value
)).json_type
286 var e
= new JsonKeyError("Value at `{sub_query}` is not a map. Got type `{val_type}`",
288 return new JsonValue(e
)
291 return new JsonValue(value
)
294 # Concatenate all keys up to `last` for debugging purposes.
296 # Note: This method deletes elements in `keys`.
297 private fun sub_query_to_s
(keys
: Array[String], last
: Int): String do
299 for j
in [last
..keys
.length
[ do keys
.pop
300 return keys
.join
(".")
303 # Return a human-readable description of the type.
305 # For debugging purpose only.
306 fun json_type
: String do
307 if is_array
then return "array"
308 if is_bool
then return "bool"
309 if is_float
then return "float"
310 if is_int
then return "int"
311 if is_null
then return "null"
312 if is_map
then return "map"
313 if is_string
then return "string"
314 if is_parse_error
then return "parse_error"
315 if is_error
then return "error"
320 # Keyed access failed.
324 # The value on which the access was requested.
325 var json_value
: JsonValue
329 # In the case of `JsonValue.get`, the sub-query that failed.
334 # Parse `self` to obtain a `JsonValue`
335 fun to_json_value
: JsonValue do
336 var value
= parse_json
337 return new JsonValue(value
)